implements Serializable, Comparable<File>

{

/**

private static final FileSystem fs = DefaultFileSystem.getFileSystem();

/**

private final String path;

/**

private static enum PathStatus { INVALID, CHECKED };

/**

private transient PathStatus status = null;

/**

final boolean isInvalid() {

PathStatus s = status;

if (s == null) {

s = (this.path.indexOf('\u0000') < 0) ? PathStatus.CHECKED

: PathStatus.INVALID;

status = s;

}

return s == PathStatus.INVALID;

}

/**

private final transient int prefixLength;

/**

int getPrefixLength() {

return prefixLength;

}

/**

public static final char separatorChar = fs.getSeparator();

/**

public static final String separator = "" + separatorChar;

/**

public static final char pathSeparatorChar = fs.getPathSeparator();

/**

public static final String pathSeparator = "" + pathSeparatorChar;

/* -- Constructors -- */

/**

private File(String pathname, int prefixLength) {

this.path = pathname;

this.prefixLength = prefixLength;

}

/**

private File(String child, File parent) {

assert parent.path != null;

assert (!parent.path.isEmpty());

this.path = fs.resolve(parent.path, child);

this.prefixLength = parent.prefixLength;

}

/**

public File(String pathname) {

if (pathname == null) {

throw new NullPointerException();

}

this.path = fs.normalize(pathname);

this.prefixLength = fs.prefixLength(this.path);

}

/* Note: The two-argument File constructors do not interpret an empty

/**

public File(String parent, String child) {

if (child == null) {

throw new NullPointerException();

}

if (parent != null) {

if (parent.isEmpty()) {

this.path = fs.resolve(fs.getDefaultParent(),

fs.normalize(child));

} else {

this.path = fs.resolve(fs.normalize(parent),

fs.normalize(child));

}

} else {

this.path = fs.normalize(child);

}

this.prefixLength = fs.prefixLength(this.path);

}

/**

public File(File parent, String child) {

if (child == null) {

throw new NullPointerException();

}

if (parent != null) {

if (parent.path.isEmpty()) {

this.path = fs.resolve(fs.getDefaultParent(),

fs.normalize(child));

} else {

this.path = fs.resolve(parent.path,

fs.normalize(child));

}

} else {

this.path = fs.normalize(child);

}

this.prefixLength = fs.prefixLength(this.path);

}

/**

public File(URI uri) {

// Check our many preconditions

if (!uri.isAbsolute())

throw new IllegalArgumentException("URI is not absolute");

if (uri.isOpaque())

throw new IllegalArgumentException("URI is not hierarchical");

String scheme = uri.getScheme();

if ((scheme == null) || !scheme.equalsIgnoreCase("file"))

throw new IllegalArgumentException("URI scheme is not \"file\"");

if (uri.getRawAuthority() != null)

throw new IllegalArgumentException("URI has an authority component");

if (uri.getRawFragment() != null)

throw new IllegalArgumentException("URI has a fragment component");

if (uri.getRawQuery() != null)

throw new IllegalArgumentException("URI has a query component");

String p = uri.getPath();

if (p.isEmpty())

throw new IllegalArgumentException("URI path component is empty");

// Okay, now initialize

p = fs.fromURIPath(p);

if (File.separatorChar != '/')

p = p.replace('/', File.separatorChar);

this.path = fs.normalize(p);

this.prefixLength = fs.prefixLength(this.path);

}

/* -- Path-component accessors -- */

/**

public String getName() {

int index = path.lastIndexOf(separatorChar);

if (index < prefixLength) return path.substring(prefixLength);

return path.substring(index + 1);

}

/**

public String getParent() {

int index = path.lastIndexOf(separatorChar);

if (index < prefixLength) {

if ((prefixLength > 0) && (path.length() > prefixLength))

return path.substring(0, prefixLength);

return null;

}

return path.substring(0, index);

}

/**

public File getParentFile() {

String p = this.getParent();

if (p == null) return null;

return new File(p, this.prefixLength);

}

/**

public String getPath() {

return path;

}

/* -- Path operations -- */

/**

public boolean isAbsolute() {

return fs.isAbsolute(this);

}

/**

public String getAbsolutePath() {

return fs.resolve(this);

}

/**

public File getAbsoluteFile() {

String absPath = getAbsolutePath();

return new File(absPath, fs.prefixLength(absPath));

}

/**

public String getCanonicalPath() throws IOException {

if (isInvalid()) {

throw new IOException("Invalid file path");

}

return fs.canonicalize(fs.resolve(this));

}

/**

public File getCanonicalFile() throws IOException {

String canonPath = getCanonicalPath();

return new File(canonPath, fs.prefixLength(canonPath));

}

private static String slashify(String path, boolean isDirectory) {

String p = path;

if (File.separatorChar != '/')

p = p.replace(File.separatorChar, '/');

if (!p.startsWith("/"))

p = "/" + p;

if (!p.endsWith("/") && isDirectory)

p = p + "/";

return p;

}

/**

@Deprecated

public URL toURL() throws MalformedURLException {

if (isInvalid()) {

throw new MalformedURLException("Invalid file path");

}

return new URL("file", "", slashify(getAbsolutePath(), isDirectory()));

}

/**

public URI toURI() {

try {

File f = getAbsoluteFile();

String sp = slashify(f.getPath(), f.isDirectory());

if (sp.startsWith("//"))

sp = "//" + sp;

return new URI("file", null, sp, null);

} catch (URISyntaxException x) {

throw new Error(x); // Can't happen

}

}

/* -- Attribute accessors -- */

/**

public boolean canRead() {

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkRead(path);

}

if (isInvalid()) {

return false;

}

return fs.checkAccess(this, FileSystem.ACCESS_READ);

}

/**

public boolean canWrite() {

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkWrite(path);

}

if (isInvalid()) {

return false;

}

return fs.checkAccess(this, FileSystem.ACCESS_WRITE);

}

/**

public boolean exists() {

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkRead(path);

}

if (isInvalid()) {

return false;

}

return fs.hasBooleanAttributes(this, FileSystem.BA_EXISTS);

}

/**

public boolean isDirectory() {

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkRead(path);

}

if (isInvalid()) {

return false;

}

return fs.hasBooleanAttributes(this, FileSystem.BA_DIRECTORY);

}

/**

public boolean isFile() {

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkRead(path);

}

if (isInvalid()) {

return false;

}

return fs.hasBooleanAttributes(this, FileSystem.BA_REGULAR);

}

/**

public boolean isHidden() {

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkRead(path);

}

if (isInvalid()) {

return false;

}

return fs.hasBooleanAttributes(this, FileSystem.BA_HIDDEN);

}

/**

public long lastModified() {

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkRead(path);

}

if (isInvalid()) {

return 0L;

}

return fs.getLastModifiedTime(this);

}

/**

public long length() {

SecurityManager security = System.getSecurityManager();

if (security != null) {

security.checkRead(path);

}

if (isInvalid()) {

return 0L;

}

return fs.getLength(this);

}

/* -- File operations -- */

/**