/*******************************************************************************
* Copyright 2011 See AUTHORS file.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.badlogic.gdx.tools;
import com.badlogic.gdx.utils.Array;
import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.regex.Pattern;
/** Collects files recursively, filtering by file name. Callbacks are provided to process files and the results are collected,
* either {@link #processFile(Entry)} or {@link #processDir(Entry, ArrayList)} can be overridden, or both. The entries provided to
* the callbacks have the original file, the output directory, and the output file. If {@link #setFlattenOutput(boolean)} is
* false, the output will match the directory structure of the input.
* @author Nathan Sweet */
public class FileProcessor {
FilenameFilter inputFilter;
Comparator<File> comparator = new Comparator<File>() {
public int compare (File o1, File o2) {
return o1.getName().compareTo(o2.getName());
}
};
Array<Pattern> inputRegex = new Array();
String outputSuffix;
ArrayList<Entry> outputFiles = new ArrayList();
boolean recursive = true;
boolean flattenOutput;
Comparator<Entry> entryComparator = new Comparator<Entry>() {
public int compare (Entry o1, Entry o2) {
return comparator.compare(o1.inputFile, o2.inputFile);
}
};
public FileProcessor () {
}
/** Copy constructor. */
public FileProcessor (FileProcessor processor) {
inputFilter = processor.inputFilter;
comparator = processor.comparator;
inputRegex.addAll(processor.inputRegex);
outputSuffix = processor.outputSuffix;
recursive = processor.recursive;
flattenOutput = processor.flattenOutput;
}
public FileProcessor setInputFilter (FilenameFilter inputFilter) {
this.inputFilter = inputFilter;
return this;
}
/** Sets the comparator for {@link #processDir(Entry, ArrayList)}. By default the files are sorted by alpha. */
public FileProcessor setComparator (Comparator<File> comparator) {
this.comparator = comparator;
return this;
}
public FileProcessor addInputSuffix (String... suffixes) {
for (String suffix : suffixes)
addInputRegex(".*" + Pattern.quote(suffix));
return this;
}
public FileProcessor addInputRegex (String... regexes) {
for (String regex : regexes)
inputRegex.add(Pattern.compile(regex));
return this;
}
/** Sets the suffix for output files, replacing the extension of the input file. */
public FileProcessor setOutputSuffix (String outputSuffix) {
this.outputSuffix = outputSuffix;
return this;
}
public FileProcessor setFlattenOutput (boolean flattenOutput) {
this.flattenOutput = flattenOutput;
return this;
}
/** Default is true. */
public FileProcessor setRecursive (boolean recursive) {
this.recursive = recursive;
return this;
}
/** @param outputRoot May be null.
* @see #process(File, File) */
public ArrayList<Entry> process (String inputFile, String outputRoot) throws Exception {
return process(new File(inputFile), outputRoot == null ? null : new File(outputRoot));
}
/** Processes the specified input file or directory.
* @param outputRoot May be null if there is no output from processing the files.
* @return the processed files added with {@link #addProcessedFile(Entry)}. */
public ArrayList<Entry> process (File inputFile, File outputRoot) throws Exception {
if (!inputFile.exists()) throw new IllegalArgumentException("Input file does not exist: " + inputFile.getAbsolutePath());
if (inputFile.isFile())
return process(new File[] {inputFile}, outputRoot);
else
return process(inputFile.listFiles(), outputRoot);
}
/** Processes the specified input files.
* @param outputRoot May be null if there is no output from processing the files.
* @return the processed files added with {@link #addProcessedFile(Entry)}. */
public ArrayList<Entry> process (File[] files, File outputRoot) throws Exception {
if (outputRoot == null) outputRoot = new File("");
outputFiles.clear();
LinkedHashMap<File, ArrayList<Entry>> dirToEntries = new LinkedHashMap();
process(files, outputRoot, outputRoot, dirToEntries, 0);
ArrayList<Entry> allEntries = new ArrayList();
for (java.util.Map.Entry<File, ArrayList<Entry>> mapEntry : dirToEntries.entrySet()) {
ArrayList<Entry> dirEntries = mapEntry.getValue();
if (comparator != null) Collections.sort(dirEntries, entryComparator);
File inputDir = mapEntry.getKey();
File newOutputDir = null;
if (flattenOutput)
newOutputDir = outputRoot;
else if (!dirEntries.isEmpty()) //
newOutputDir = dirEntries.get(0).outputDir;
String outputName = inputDir.getName();
if (outputSuffix != null) outputName = outputName.replaceAll("(.*)\\..*", "$1") + outputSuffix;
Entry entry = new Entry();
entry.inputFile = mapEntry.getKey();
entry.outputDir = newOutputDir;
if (newOutputDir != null)
entry.outputFile = newOutputDir.length() == 0 ? new File(outputName) : new File(newOutputDir, outputName);
try {
processDir(entry, dirEntries);
} catch (Exception ex) {
throw new Exception("Error processing directory: " + entry.inputFile.getAbsolutePath(), ex);
}
allEntries.addAll(dirEntries);
}
if (comparator != null) Collections.sort(allEntries, entryComparator);
for (Entry entry : allEntries) {
try {
processFile(entry);
} catch (Exception ex) {
throw new Exception("Error processing file: " + entry.inputFile.getAbsolutePath(), ex);
}
}
return outputFiles;
}
private void process (File[] files, File outputRoot, File outputDir, LinkedHashMap<File, ArrayList<Entry>> dirToEntries,
int depth) {
// Store empty entries for every directory.
for (File file : files) {
File dir = file.getParentFile();
ArrayList<Entry> entries = dirToEntries.get(dir);
if (entries == null) {
entries = new ArrayList();
dirToEntries.put(dir, entries);
}
}
for (File file : files) {
if (file.isFile()) {
if (inputRegex.size > 0) {
boolean found = false;
for (Pattern pattern : inputRegex) {
if (pattern.matcher(file.getName()).matches()) {
found = true;
continue;
}
}
if (!found) continue;
}
File dir = file.getParentFile();
if (inputFilter != null && !inputFilter.accept(dir, file.getName())) continue;
String outputName = file.getName();
if (outputSuffix != null) outputName = outputName.replaceAll("(.*)\\..*", "$1") + outputSuffix;
Entry entry = new Entry();
entry.depth = depth;
entry.inputFile = file;
entry.outputDir = outputDir;
if (flattenOutput) {
entry.outputFile = new File(outputRoot, outputName);
} else {
entry.outputFile = new File(outputDir, outputName);
}
dirToEntries.get(dir).add(entry);
}
if (recursive && file.isDirectory()) {
File subdir = outputDir.getPath().length() == 0 ? new File(file.getName()) : new File(outputDir, file.getName());
process(file.listFiles(inputFilter), outputRoot, subdir, dirToEntries, depth + 1);
}
}
}
/** Called with each input file. */
protected void processFile (Entry entry) throws Exception {
}
/** Called for each input directory. The files will be {@link #setComparator(Comparator) sorted}. */
protected void processDir (Entry entryDir, ArrayList<Entry> files) throws Exception {
}
/** This method should be called by {@link #processFile(Entry)} or {@link #processDir(Entry, ArrayList)} if the return value of
* {@link #process(File, File)} or {@link #process(File[], File)} should return all the processed files. */
protected void addProcessedFile (Entry entry) {
outputFiles.add(entry);
}
/** @author Nathan Sweet */
static public class Entry {
public File inputFile;
/** May be null. */
public File outputDir;
public File outputFile;
public int depth;
public Entry () {
}
public Entry (File inputFile, File outputFile) {
this.inputFile = inputFile;
this.outputFile = outputFile;
}
public String toString () {
return inputFile.toString();
}
}
}