diff options
Diffstat (limited to 'src/compiler/scala/tools/util/AbstractFile.java')
-rw-r--r-- | src/compiler/scala/tools/util/AbstractFile.java | 128 |
1 files changed, 128 insertions, 0 deletions
diff --git a/src/compiler/scala/tools/util/AbstractFile.java b/src/compiler/scala/tools/util/AbstractFile.java new file mode 100644 index 0000000000..723d983a4a --- /dev/null +++ b/src/compiler/scala/tools/util/AbstractFile.java @@ -0,0 +1,128 @@ +/* ____ ____ ____ ____ ______ *\ +** / __// __ \/ __// __ \/ ____/ SOcos COmpiles Scala ** +** __\_ \/ /_/ / /__/ /_/ /\_ \ (c) 2002, LAMP/EPFL ** +** /_____/\____/\___/\____/____/ ** +\* */ + +// $Id$ + +package scala.tools.util; + +import java.io.File; +import java.io.IOException; +import java.util.Iterator; +import java.util.jar.JarFile; +import java.util.zip.ZipFile; + +/** + * This class implements an abstract representation of files and + * directories. These files and directories may have some real counter + * part within the file system but that is not necessarily true. For + * example, there exist abstract files that represent files within a + * zip archive or files that exist only in memory. + * + * Every abstract file has a path (i.e. a full name) and a name + * (i.e. a short name) and may be backed by some real File. There are + * two different kinds of abstract files: regular files and + * directories. Regular files may be read and have a last modification + * time. Directories may list their content and look for subfiles with + * a specified name or path and of a specified kind. + */ +public abstract class AbstractFile { + + //######################################################################## + // Public Factories + + /** Returns "getFile(new File(path))". */ + public static AbstractFile getFile(String path) { + return getFile(new File(path)); + } + + /** + * If the specified File exists and is a regular file, returns an + * abstract regular file backed by it. Otherwise, returns null. + */ + public static AbstractFile getFile(File file) { + return file.isFile() ? new PlainFile(file) : null; + } + + + /** Returns "getDirectory(new File(path))". */ + public static AbstractFile getDirectory(String path) { + return getDirectory(new File(path)); + } + + /** + * if the specified File exists and is either a directory or a + * readable zip or jar archive, returns an abstract directory + * backed by it. Otherwise, returns null. + */ + public static AbstractFile getDirectory(File file) { + if (file.isDirectory()) return new PlainFile(file); + if (file.isFile()) { + String path = file.getPath(); + if (path.endsWith(".jar") || path.endsWith(".zip")) + return ZipArchive.fromFile(file); + } + return null; + } + + //######################################################################## + // Public Methods + + /** Returns the name of this abstract file. */ + public abstract String getName(); + + /** Returns the path of this abstract file. */ + public abstract String getPath(); + + /** Returns the underlying File if any and null otherwise. */ + public abstract File getFile(); + + /** Is this abstract file a directory? */ + public abstract boolean isDirectory(); + + /** Returns the time that this abstract file was last modified. */ + public abstract long lastModified(); + + /** Reads the content of this abstract file into a byte array. */ + public abstract byte[] read() throws IOException; + + /** Returns all abstract subfiles of this abstract directory. */ + public abstract Iterator/*<AbstractFile>*/ list(); + + /** + * Returns the abstract file in this abstract directory with the + * specified name. If there is no such file, returns null. The + * argument "directory" tells whether to look for a directory or + * or a regular file. + */ + public abstract AbstractFile lookupName(String name, boolean directory); + + /** + * Returns the abstract file in this abstract directory with the + * specified path relative to it, If there is no such file, + * returns null. The argument "directory" tells whether to look + * for a directory or or a regular file. + */ + public final AbstractFile lookupPath(String path, boolean directory) { + final int length = path.length(); + final char separator = File.separatorChar; + assert 0 < length && path.lastIndexOf(separator) < length - 1: path; + AbstractFile file = this; + for (int start = 0, index; true; start = index + 1) { + index = path.indexOf(separator, start); + assert index < 0 || start < index: path+" - "+start+" - "+index; + String name = path.substring(start, index < 0 ? length : index); + file = file.lookupName(name, index < 0 ? directory : true); + if (file == null || index < 0) return file; + } + } + + /** Returns the path of this abstract file. */ + public final String toString() { + return getPath(); + } + + //######################################################################## +} |