org.eclipse.jgit.treewalk.FileTreeIterator Maven / Gradle / Ivy
/*
* Copyright (C) 2008, Google Inc.
* Copyright (C) 2007-2010, Robin Rosenberg
* Copyright (C) 2008, Shawn O. Pearce
* Copyright (C) 2009, Tor Arne Vestbø
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.eclipse.jgit.treewalk;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
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.ObjectReader;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.util.FS;
/**
* Working directory iterator for standard Java IO.
*
* This iterator uses the standard java.io package to read the
* specified working directory as part of a {@link TreeWalk}.
*/
public class FileTreeIterator extends WorkingTreeIterator {
/**
* the starting directory. This directory should correspond to the root of
* the repository.
*/
protected final File directory;
/**
* the file system abstraction which will be necessary to perform certain
* file system operations.
*/
protected final FS fs;
/**
* Create a new iterator to traverse the work tree and its children.
*
* @param repo
* the repository whose working tree will be scanned.
*/
public FileTreeIterator(Repository repo) {
this(repo.getWorkTree(), repo.getFS(),
repo.getConfig().get(WorkingTreeOptions.KEY));
initRootIterator(repo);
}
/**
* Create a new iterator to traverse the given directory and its children.
*
* @param root
* the starting directory. This directory should correspond to
* the root of the repository.
* @param fs
* the file system abstraction which will be necessary to perform
* certain file system operations.
* @param options
* working tree options to be used
*/
public FileTreeIterator(final File root, FS fs, WorkingTreeOptions options) {
super(options);
directory = root;
this.fs = fs;
init(entries());
}
/**
* Create a new iterator to traverse a subdirectory.
*
* @param p
* the parent iterator we were created from.
* @param fs
* the file system abstraction which will be necessary to perform
* certain file system operations.
* @param root
* the subdirectory. This should be a directory contained within
* the parent directory.
*/
protected FileTreeIterator(final FileTreeIterator p, final File root, FS fs) {
super(p);
directory = root;
this.fs = fs;
init(entries());
}
@Override
public AbstractTreeIterator createSubtreeIterator(final ObjectReader reader)
throws IncorrectObjectTypeException, IOException {
return new FileTreeIterator(this, ((FileEntry) current()).file, fs);
}
private Entry[] entries() {
final File[] all = directory.listFiles();
if (all == null)
return EOF;
final Entry[] r = new Entry[all.length];
for (int i = 0; i < r.length; i++)
r[i] = new FileEntry(all[i], fs);
return r;
}
/**
* Wrapper for a standard Java IO file
*/
static public class FileEntry extends Entry {
final File file;
private final FileMode mode;
private long length = -1;
private long lastModified;
FileEntry(final File f, FS fs) {
file = f;
if (f.isDirectory()) {
if (new File(f, Constants.DOT_GIT).exists())
mode = FileMode.GITLINK;
else
mode = FileMode.TREE;
} else if (fs.canExecute(file))
mode = FileMode.EXECUTABLE_FILE;
else
mode = FileMode.REGULAR_FILE;
}
@Override
public FileMode getMode() {
return mode;
}
@Override
public String getName() {
return file.getName();
}
@Override
public long getLength() {
if (length < 0)
length = file.length();
return length;
}
@Override
public long getLastModified() {
if (lastModified == 0)
lastModified = file.lastModified();
return lastModified;
}
@Override
public InputStream openInputStream() throws IOException {
return new FileInputStream(file);
}
/**
* Get the underlying file of this entry.
*
* @return the underlying file of this entry
*/
public File getFile() {
return file;
}
}
/**
* @return The root directory of this iterator
*/
public File getDirectory() {
return directory;
}
/**
* @return The location of the working file. This is the same as {@code new
* File(getDirectory(), getEntryPath())} but may be faster by
* reusing an internal File instance.
*/
public File getEntryFile() {
return ((FileEntry) current()).getFile();
}
@Override
protected byte[] idSubmodule(final Entry e) {
if (repository == null)
return idSubmodule(getDirectory(), e);
return super.idSubmodule(e);
}
}