/* * Copyright (c) 1999, 2007 Sun Microsystems, Inc. * 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. * * -Redistribution 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 Sun Microsystems, Inc. or the names of contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * This software is provided "AS IS," without a warranty of any kind. ALL * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR * PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS * SHALL NOT BE LIABLE FOR ANY DAMAGES OR LIABILITIES SUFFERED BY LICENSEE * AS A RESULT OF OR RELATING TO USE, MODIFICATION OR DISTRIBUTION OF THE * SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE * LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, * SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED * AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR * INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE * POSSIBILITY OF SUCH DAMAGES. * * You acknowledge that this software is not designed,licensed or intended * for use in the design, construction, operation or maintenance of any * nuclear facility. */ package com.sun.xfile; import java.io.*; import java.util.Vector; import java.lang.reflect.Constructor; import java.util.Hashtable; import java.util.StringTokenizer; /** * * Instances of this class represent the name of a file or directory. * Since only the name of the file is represented, the file itself * need not exist. *

* The XFile object is functionally equivalent to the java.io.File * object with the ability to handle not only native pathnames * but also URL-style pathnames. URL pathnames have some advantages * over native pathnames: *

*

*

* * Pathnames that are not represented as URL names will be * assumed to represent "native" names and XFile will present * the same semantics as the java.io.File class. */ public class XFile { /** * File Accessor that implements the underlying filesystem */ private XFileAccessor xfa; /** * The url of the file. */ private XFurl url; private String urlStr; private File nativeFile; private boolean bound; /** * Creates a XFile instance that represents the file * whose pathname is the given url argument. * * If the the name argument contains the string "://" then it * is assumed to be a URL name. The characters prior to the * colon are assumed to be the filesystem scheme name, e.g. * "file", "nfs", etc. The rest of the URL name is assumed * to be structured according to the Common Internet Scheme * syntax described in * RFC 1738; * an optional location part followed by a hierarchical set * of slash separated directories. *

* <scheme>://<location>/<path> * * @param name the file url * @exception java.lang.NullPointerException if the file url * is equal to null. */ public XFile(String name) { urlStr = name; if (name == null) throw new NullPointerException(); try { url = new XFurl(name); xfa = loadAccessor(url); } catch (Exception e) { if (name.startsWith(".:")) name = name.substring(2); // lop off ".:" nativeFile = new File(name); xfa = makeNative(nativeFile); } } /** * Creates a XFile instance that represents the file * with the specified name in the specified directory. * * If the dir XFile is null, or if the * name string is a full URL, then the single-arg * constructor is used on the name. *

* If the dir XFile represents a native file * and the name string isAbsolute * then the single-arg constructor is used on the name. * If the name is not absolute then the resulting * path is the simple concatenation of the dir * path with the file separator and the name as * for the two-arg constructor of the File class. *

* If the dir XFile represents a URL name then * the dir is assumed to be a base URL * and the name string is evaluated as a * relative URL according to the rules described in * RFC 1808. * *

* * * * * * * * * * * * * * * * * * * * * * * * * * * * *
DirNameComposition
file:///a/b/cxfile:///a/b/c/x
nfs://server/a/b/c/ynfs://server/y
nfs://server/a/b/c../znfs://server/a/b/z
file:///a/b/cd/.nfs://server/a/b/c/d
file:///a/b/cnfs://srv/xnfs://srv/x
C:\Data\Programsmyprog.exeC:\Data\Programs\myprog.exe
*
* * @param dir the directory. * @param name absolute or relative file name or URL */ public XFile(XFile dir, String name) { if (name == null) throw new NullPointerException(); try { url = new XFurl(name); xfa = loadAccessor(url); } catch (Exception e) { /* * If the name starts with ".:" then its * a "native" URL - not relative. */ if (name.startsWith(".:")) { name = name.substring(2); // lop off ".:" dir = null; } /* * The name is not a URL * If dir is not a URL then * make a native file. */ if (dir == null) { nativeFile = new File(name); xfa = makeNative(nativeFile); /* * Departure from strict java.io semantics here: * If name is absolute then ignore the dir. */ } else if (dir.nativeFile != null) { if (new File(name).isAbsolute()) nativeFile = new File(name); else nativeFile = new File(dir.nativeFile, name); xfa = makeNative(nativeFile); /* * If the dir is a URL then evaluate * name as a relative URL (see RFC 1808) */ } else { try { url = new XFurl(dir.getURL(), name); xfa = loadAccessor(url); } catch (Exception ee) { System.out.println("Error: " + dir.getURL() + " " + name); } } } urlStr = url.toString(); } /* * Extract the protocol scheme from the url and * load a class for an XFileAccessor or XFileExtensionAccessor * * The accessor is located by constructing a package * name that contains the scheme string which is then * located relative to the CLASSPATH. * * The package name is constructed from three components: * * . . * * The default package prefix is "com.sun" however this may * changed by setting of the System property "java.protocol.xfile" * to the value of one or more alternative prefixes delimited * by vertical bars. The list is searched until the XFileAccessor * is found. This method of locating accessors is similar to that * of java.net.URL protocol handlers. The suffix is either * "XFileAccessor" or "XFileExtensionAccessor". * * The hash table is used as a cache for previously loaded classes. */ private Class loadClass(String proto, String suffix, Hashtable ht) throws ClassNotFoundException, IllegalAccessException { /* * Check if there's a cached class for this protocol */ Class cl = (Class)ht.get(proto); if (cl != null) return cl; String prefixList = null; try { // applets will get a security exception here prefixList = System.getProperty("java.protocol.xfile"); } catch (SecurityException e) {}; if (prefixList == null) prefixList = ""; else prefixList += "|"; prefixList += "com.sun"; // always the default StringTokenizer pkgs = new StringTokenizer(prefixList, "|"); while (cl == null && pkgs.hasMoreTokens()) { String prefix = pkgs.nextToken().trim(); String clname = prefix + "." + proto + "." + suffix; try { cl = Class.forName(clname); } catch (Exception e) {}; } if (cl == null) throw new ClassNotFoundException(); ht.put(proto, cl); return (cl); } /* * A table of cached XFileAccessors */ static Hashtable cachedAccessors = new Hashtable(); /* * Load an XFileAccessor */ private XFileAccessor loadAccessor(XFurl url) throws ClassNotFoundException, IllegalAccessException, InstantiationException { Class cl = loadClass(url.getProtocol(), "XFileAccessor", cachedAccessors); if (cl == null) return null; return (XFileAccessor)cl.newInstance(); } /* * Return a file accessor that corresponds * to a native file. */ private XFileAccessor makeNative(File f) { char sep = f.separatorChar; try { url = new XFurl("file:///" + f.getPath().replace(sep, '/')); return loadAccessor(url); } catch (Exception e) { System.out.println("Error: makenative:" + f.getPath()); return null; } } /* * Check that the file is open. * The open() method must be called before * any other methods in the Accessor. * This makes it easier for Accessors to * centralize initialization code in one place. */ private boolean bind() { if (bound) return true; bound = xfa.open(this, false, false); return bound; } /* * Return the bound status */ private boolean getBound() { return bound; } /* * Get the native file */ private File getNative() { return nativeFile; } /* * Get a new XFileAccessor for this object */ protected XFileAccessor newAccessor() { try { return loadAccessor(url); } catch (Exception e) { return makeNative(nativeFile); } } /* * Get the XFileAccessor for this Object * * @return XFileAccessor */ private XFileAccessor getAccessor() { return xfa; } /* * A table of cached XFileExtensionAccessors */ static Hashtable cachedExtensionAccessors = new Hashtable(); /** * Get the XFileExtensionAccessor * * @return instance of XFileExtensionAccessor or null * if there is no XFileExtensionAccessor. */ public XFileExtensionAccessor getExtensionAccessor() { try { /* * XXX The following ugly code avoids a ClassCastException * for old apps using the deprecated * nfsXFileExtensionAccessor class. */ String suffix; if (url.getProtocol().equals("nfs")) suffix = "nfsXFileExtensionAccessor"; else suffix = "XFileExtensionAccessor"; Class cl = loadClass(url.getProtocol(), suffix, cachedExtensionAccessors); Constructor con = cl.getConstructor(new Class[]{this.getClass()}); return (XFileExtensionAccessor)con.newInstance(new Object[]{this}); } catch (Exception e) { return null; } } /* * Get the XFile URL */ private XFurl getURL() { return url; } /** * Returns the name of the filesystem, the string before * the colon of the URL. * * If this XFile represents a native path then the * "file" filesystem will be returned. * * @return the name of the filesystem. */ public String getFileSystemName() { return url.getProtocol(); } /** * Returns the name of the file represented by this object. * * The name is the last component of the pathname. * For a URL this is the last, non-terminating slash. * For a native file it is the portion of the pathname after * the last occurrence of the separator character. * * @return the name of the file (without any directory components) * represented by this XFile object. */ public String getName() { if (nativeFile != null) return nativeFile.getName(); return url.getName(); } /** * Returns the pathname of the file represented by this object. * * @return the pathname represented by this XFile * object. *

* If the object is a URL type, the path is the part * of the URL following the location, e.g. *

* new XFile("nfs://location/a/b/c").getPath() * == "a/b/c" *

* new XFile("file:///a/b/c").getPath() * == "a/b/c" *

* new XFile("nfs://server/").getPath() * == "" */ public String getPath() { if (nativeFile != null) return nativeFile.getPath(); return url.getPath(); } /** * Returns the absolute pathname of the file represented by this * object. * * If this object is represented by a native pathname and is an * absolute pathname, then return the pathname. Otherwise, return * a pathname that is a concatenation of the current user * directory, the separator character, and the pathname of this * file object. * The system property user.dir contains the current * user directory. *

* If the object is represented by a URL then return the entire URL * string. * * @return a system-dependent absolute pathname for this * XFile. */ public String getAbsolutePath() { if (nativeFile != null) return nativeFile.getAbsolutePath(); return urlStr; } /** * Returns the canonical form of this XFile object's * pathname. * * If the object is represented by a URL name then the full * URL is always returned. URL names are always canonical. *

* For native paths the precise definition of canonical form * is system-dependent, but it usually specifies an absolute * pathname in which all relative references and references * to the current user directory have been completely * resolved. The canonical form of a pathname of a nonexistent * file may not be defined. * * @return the canonical path of the object * @exception java.io.IOException If an I/O error occurs, which * is possible because the construction of the * canonical path may require filesystem queries. */ public String getCanonicalPath() throws IOException { if (nativeFile != null) return nativeFile.getCanonicalPath(); return urlStr; } /** * Returns the parent part of the pathname of this * XFile object, or null if the name * has no parent part. * * If the name is a URL then the parent part is the URL with * the last component of the pathname removed. If the URL * has no pathname part, then the URL is returned unchanged. *

* For native paths the parent part is generally everything * leading up to the last occurrence of the separator character, * although the precise definition is system dependent. * On UNIX, for example, the parent part of "/usr/lib" * is "/usr" whose parent part is "/", * which in turn has no parent. * On Windows platforms, the parent part of "c:\java" * is "c:\", which in turn has no parent. * * @return the name of the parent directory */ public String getParent() { if (nativeFile != null) return nativeFile.getParent(); return url.getParent(); } /** * Tests if the file represented by this XFile * object is an absolute pathname. * * If the object is represented by a URL then true * is always returned.
* If the XFile represents a native name then * the definition of an absolute pathname is system * dependent. For example, on UNIX, a pathname is absolute if its * first character is the separator character. * On Windows platforms, * a pathname is absolute if its first character is an ASCII * '\' or '/', or if it begins with a letter followed by * a colon. * * @return true if the pathname indicated by the * XFile object is an absolute pathname; * false otherwise. */ public boolean isAbsolute() { if (nativeFile != null) return nativeFile.isAbsolute(); return true; } /** * Tests if this XFile exists. * * @return true if the file specified by this object * exists; false otherwise. */ public boolean exists() { if (!bind()) return false; return xfa.exists(); } /** * Tests if the application can write to this file. * * @return true if the application is allowed to * write to a file whose name is specified by this object; * false otherwise. */ public boolean canWrite() { if (!bind()) return false; return xfa.canWrite(); } /** * Tests if the application can read from the specified file. * * @return true if the file specified by this * object exists and the application can read the file; * false otherwise. */ public boolean canRead() { if (!bind()) return false; return xfa.canRead(); } /** * Tests if the file represented by this XFile * object is a "normal" file. * * A file is "normal" if it is not a directory and, in * addition, satisfies other system-dependent criteria. Any * non-directory file created by a Java application is guaranteed * to be a normal file. * * @return true if the file specified by this object * exists and is a "normal" file; false * otherwise. */ public boolean isFile() { if (!bind()) return false; return xfa.isFile(); } /** * Tests if the file represented by this XFile * object is a directory. * * @return true if this XFile exists * and is a directory; false otherwise. */ public boolean isDirectory() { if (!bind()) return false; return xfa.isDirectory(); } /** * Returns the time that the file represented by this * XFile object was last modified. *

* The return value is system dependent and should only be used to * compare with other values returned by last modified. It should * not be interpreted as an absolute time. * * @return the time the file specified by this object was last * modified, or 0L if the specified file * does not exist. */ public long lastModified() { if (!bind()) return 0L;; return xfa.lastModified(); } /** * Returns the length of the file represented by this * XFile object. * * @return the length, in bytes, of the file specified by this * object, or 0L if the specified file does * not exist. The length constitutes the number of bytes * readable via an InputStream. The length value for * a directory is undefined. */ public long length() { if (!bind()) return 0L; return xfa.exists() ? xfa.length() : 0L; } /** * Renames the file specified by this XFile object to * have the pathname given by the XFile argument. * * This object and dest must represent filesystems * of the same type. For instance: both native or both of * the same URL scheme. * * After a successful renameTo, this object continues to * be a valid reference to the file. Only the name * is different. * * If the destination filename already exists, it will be replaced. * The application must have permission to modify the source and * destination directory. * * @param dest the new filename. * @return true if the renaming succeeds; * false otherwise. */ public boolean renameTo(XFile dest) { if (dest == null) throw new NullPointerException(); if (! xfa.getClass().isInstance(dest.getAccessor())) return false; if (!bind()) return false; boolean ok = xfa.renameTo(dest); /* * Only the name of the file is changed. * Its data and state are unaffected. * Hence we make this XFile object a clone * of the dest XFile. */ if (ok) { url = dest.getURL(); urlStr = dest.getAbsolutePath(); nativeFile = dest.getNative(); xfa = dest.getAccessor(); bound = dest.getBound(); } return ok; } /** * Creates a directory whose pathname is specified by this * XFile object. * * If any parent directories in the pathname do not * exist, the method will return false. * * @return true if the directory could be created; * false otherwise. */ public boolean mkdir() { bind(); return xfa.mkdir(); } /** * Creates a directory whose pathname is specified by this * XFile object, including any necessary parent * directories. * * @return true if the directory (or directories) * could be created; false otherwise. */ public boolean mkdirs() { bind(); if (exists()) { return false; } if (mkdir()) { return true; } String parent = getParent(); return (parent != null) && (new XFile(parent).mkdirs() && mkdir()); } /** * Returns a list of the files in the directory specified by this * XFile object. * * @return an array of file names in the specified directory. * This list does not include the current directory or the * parent directory ("." and ".." * on Unix systems). */ public String[] list() { if (!bind()) return null;; return xfa.list(); } /** * Returns a list of the files in the directory specified by this * XFile that satisfy the specified filter. * * @param filter a filename filter. * @return an array of file names in the specified directory. * This list does not include the current directory or the * parent directory ("." and ".." * on Unix systems). * @see com.sun.xfilenameFilter */ public String[] list(XFilenameFilter filter) { if (!bind()) return null;; String names[] = list(); if (names == null) { return null; } // Fill in the Vector Vector v = new Vector(); for (int i = 0 ; i < names.length ; i++) { if ((filter == null) || filter.accept(this, names[i])) { v.addElement(names[i]); } } // Create the array String files[] = new String[v.size()]; v.copyInto(files); return files; } /** * Deletes the file specified by this object. * If the target file to be deleted is a directory, it must be * empty for deletion to succeed. * * @return true if the file is successfully deleted; * false otherwise. */ public boolean delete() { if (!bind()) return false;; boolean ok = xfa.delete(); bound = !ok; return ok; } /** * Computes a hashcode for the file. * * @return a hash code value for this XFile object. */ public int hashCode() { return urlStr.hashCode() ^ 1234321; } /** * Compares this object against the specified object. * * Returns true if and only if the argument is * not null and is a XFile object whose * pathname is equal to the pathname of this object. * * @param obj the object to compare with. * @return true if the objects are the same; * false otherwise. */ public boolean equals(Object obj) { if ((obj == null) || (! (obj instanceof XFile))) return false; return url.toString().equals(((XFile)obj).getURL().toString()); } /** * Returns a string representation of this object. * * @return a string giving the pathname of this object. */ public String toString() { if (nativeFile != null) return (nativeFile.toString()); return urlStr; } }