file.separator system property.
* An example separator string would be "/" on the GNU system.
*/
public static final String separator = System.getProperty("file.separator");
/**
* This is the first character of the file separator string. On many
* hosts (for example, on the GNU system), this represents the entire
* separator string. The complete separator string is obtained from the
* file.separatorsystem property.
*/
public static final char separatorChar = separator.charAt(0);
/**
* This is the string that is used to separate the host name from the
* path name in paths than include the host name. It is the value of
* the path.separator system property.
*/
public static final String pathSeparator = System.getProperty("path.separator");
/**
* This is the first character of the string used to separate the host name
* from the path name in paths that include a host. The separator string
* is taken from the path.separator system property.
*/
public static final char pathSeparatorChar = pathSeparator.charAt(0);
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary ("javaio");
}
}
/*************************************************************************/
/*
* Instance Variables
*/
/**
* This is the path to the file set when the object is created. It
* may be an absolute or relative path name.
*/
private String path;
/*************************************************************************/
/*
* Class Methods
*/
/**
* This method creates a temporary file in the system temporary directory. The
* files created are guaranteed not to currently exist and the same file name
* will never be used twice in the same virtual machine instance. The
* system temporary directory is determined by examinging the
* java.tmpdir system property.
*
* The prefix parameter is a sequence of at least three
* characters that are used as the start of the generated filename. The
* suffix parameter is a sequence of characters that is used
* to terminate the file name. This parameter may be null
* and if it is, the suffix defaults to ".tmp".
*
* If a SecurityManager exists, then its checkWrite
* method is used to verify that this operation is permitted.
*
* This method is identical to calling
* createTempFile(prefix, suffix, null).
*
* @param prefix The character prefix to use in generating the path name.
* @param suffix The character suffix to use in generating the path name.
*
* @exception IllegalArgumentException If the prefix or suffix are not valid.
* @exception SecurityException If there is no permission to perform this operation
* @exception IOException If an error occurs
*/
public static File
createTempFile(String prefix, String suffix) throws IllegalArgumentException,
SecurityException,
IOException
{
return(createTempFile(prefix, suffix, null));
}
/*************************************************************************/
/**
* This method creates a temporary file in the specified directory. If
* the directory name is null, then this method uses the system temporary
* directory. The files created are guaranteed not to currently exist and the
* same file name will never be used twice in the same virtual machine instance.
* The system temporary directory is determined by examinging the
* java.tmpdir system property.
*
* The prefix parameter is a sequence of at least three
* characters that are used as the start of the generated filename. The
* suffix parameter is a sequence of characters that is used
* to terminate the file name. This parameter may be null
* and if it is, the suffix defaults to ".tmp".
*
* If a SecurityManager exists, then its checkWrite
* method is used to verify that this operation is permitted.
*
* @param prefix The character prefix to use in generating the path name.
* @param suffix The character suffix to use in generating the path name.
* @param directory The directory to create the file in, or null for the default temporary directory
*
* @exception IllegalArgumentException If the patterns is not valid
* @exception SecurityException If there is no permission to perform this operation
* @exception IOException If an error occurs
*/
public static synchronized File
createTempFile(String prefix, String suffix, File directory)
throws IllegalArgumentException, SecurityException, IOException
{
// Grab the system temp directory if necessary
if (directory == null)
{
String dirname = System.getProperty("java.tmpdir");
if (dirname == null)
throw new IOException("Cannot determine system temporary directory");
directory = new File(dirname);
if (!directory.exists())
throw new IOException("System temporary directory " +
directory.getName() + " does not exist.");
if (!directory.isDirectory())
throw new IOException("System temporary directory " +
directory.getName() + " is not really a directory.");
}
// Now process the prefix and suffix.
if (prefix.length() < 3)
throw new IllegalArgumentException("Prefix too short: " + prefix);
if (suffix == null)
suffix = ".tmp";
// Now identify a file name and make sure it doesn't exist
File f;
for(;;)
{
String filename = prefix + System.currentTimeMillis() + suffix;
f = new File(directory, filename);
if (f.exists())
continue;
else
break;
}
// Verify that we are allowed to create this file
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkWrite(f.getAbsolutePath());
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
// Now create the file and return our file object
createInternal(f.getAbsolutePath());
return(f);
}
/*************************************************************************/
/**
* This method is used to create a temporary file
*/
private static native boolean createInternal(String name) throws IOException;
/*************************************************************************/
/**
* This method returns an array of filesystem roots. Some operating systems
* have volume oriented filesystem. This method provides a mechanism for
* determining which volumes exist. GNU systems use a single hierarchical
* filesystem, so will have only one "/" filesystem root.
*
* @return An array of File objects for each filesystem root
* available.
*/
public static File[]
listRoots()
{
File[] f = new File[1];
f[0] = new File("/");
return(f);
}
/*************************************************************************/
/*
* Constructors
*/
/**
* This method initializes a new File object to represent
* a file in the specified directory. If the directory
* argument is null, the file is assumed to be in the
* current directory as specified by the user.dir system
* property
*
* @param directory The directory this file resides in
* @param name The name of the file
*/
public
File(File directory, String name)
{
if (directory == null)
{
String dirname = System.getProperty("user.dir");
if (dirname == null)
throw new IllegalArgumentException("Cannot determine default user directory");
directory = new File(dirname);
}
path = directory.getPath() + separator + name;
}
/*************************************************************************/
/**
* This method initializes a new File object to represent
* a file in the specified named directory. The path name to the file
* will be the directory name plus the separator string plus the file
* name. If the directory path name ends in the separator string, another
* separator string will still be appended.
*
* @param dirname The path to the directory the file resides in
* @param name The name of the file
*/
public
File(String dirname, String name)
{
this((name == null || dirname == null) ? name : dirname + separator + name);
}
/*************************************************************************/
/**
* This method initializes a new File object to represent
* a file with the specified path.
*
* @param name The path name of the file
*/
public
File(String name)
{
path = name;
// Per the spec
if (path == null)
throw new NullPointerException("File name is null");
}
/*************************************************************************/
/*
* Instance Methods
*/
/**
* This method returns the name of the file. This is everything in the
* complete path of the file after the last instance of the separator
* string.
*
* @return The file name
*/
public String
getName()
{
int pos = path.lastIndexOf(separator);
if (pos == -1)
return(path);
if (path.endsWith(separator))
return("");
return(path.substring(pos + separator.length()));
}
/*************************************************************************/
/**
* Returns the path name that represents this file. May be a relative
* or an absolute path name
*
* @return The pathname of this file
*/
public String
getPath()
{
return(path);
}
/*************************************************************************/
/**
* This method returns the path of this file as an absolute path name.
* If the path name is already absolute, then it is returned. Otherwise
* the value returned is the current directory plus the separatory
* string plus the path of the file. The current directory is determined
* from the user.dir system property.
*
* @return The absolute path of this file
*/
public String
getAbsolutePath()
{
if (path.startsWith(separator))
return(path);
return(System.getProperty("user.dir") + separator + path);
}
/*************************************************************************/
/**
* This method returns a File object representing the
* absolute path of this object.
*
* @return A File with the absolute path of the object.
*/
public File
getAbsoluteFile()
{
return(new File(getAbsolutePath()));
}
/*************************************************************************/
/**
* This method returns a canonical representation of the pathname of
* this file. The actual form of the canonical representation is
* different. On the GNU system, the canonical form differs from the
* absolute form in that all relative file references to "." and ".."
* are resolved and removed.
*
* Note that this method, unlike the other methods which return path
* names, can throw an IOException. This is because native method
* might be required in order to resolve the canonical path
*
* @exception IOException If an error occurs
*/
public String
getCanonicalPath() throws IOException
{
String abspath = getAbsolutePath();
StringBuffer canonpath = new StringBuffer(separator);
StringTokenizer st = new StringTokenizer(abspath, separator);
// Traverse each element of the path, handling "." and ".."
// Should be handle "~" too?
if (st.hasMoreTokens())
do
{
String s = st.nextToken();
// Handle "." or an empty element.
if (s.equals(".") || s.equals(""))
continue;
// Handle ".." by deleting the last element from the path
if (s.equals(".."))
{
if (canonpath.equals(separator))
continue;
// Strip of trailing separator
String tmpstr = canonpath.toString().substring(0,
canonpath.length() - separator.length());
int idx = tmpstr.lastIndexOf(separator);
if ((idx == -1) || ((idx + separator.length()) > tmpstr.length()))
throw new IOException("Can't happen error"); // Shouldn't happen
tmpstr = tmpstr.substring(0, idx + separator.length());
canonpath = new StringBuffer(tmpstr);
continue;
}
canonpath.append(s);
if (st.hasMoreTokens())
canonpath.append(separator);
}
while(st.hasMoreTokens());
String tmpstr = canonpath.toString();
if (tmpstr.endsWith(separator) && !tmpstr.equals(separator))
tmpstr = tmpstr.substring(0, tmpstr.length() - 1);
return(tmpstr);
}
/*************************************************************************/
/**
* This method returns a File object representing the
* canonical path of this object.
*
* @return A File instance representing the canonical path of
* this object.
*
* @exception IOException If an error occurs.
*/
public File
getCanonicalFile() throws IOException
{
return(new File(getCanonicalPath()));
}
/*************************************************************************/
/**
* This method returns a String the represents this file's
* parent. null is returned if the file has no parent. The
* parent is determined via a simple operation which removes the
*
* @return The parent directory of this file
*/
public String
getParent()
{
if (path.equals("/"))
return(null);
String par_path;
if (path.endsWith(separator))
par_path = path.substring(0, path.length() - 1);
else
par_path = path;
int pos = par_path.lastIndexOf(separator);
if (pos == -1)
return(null);
return(par_path.substring(0, pos));
}
/*************************************************************************/
/**
* This method returns a File object representing the parent
* file of this one.
*
* @param A File for the parent of this object. null
* will be returned if this object does not have a parent.
*/
public File
getParentFile()
{
String parent = getParent();
if (parent == null)
return(null);
return(new File(parent));
}
/*************************************************************************/
/**
* This method returns true if this object represents an absolute file
* path and false if it does not. The definition of an absolute path varies
* by system. As an example, on GNU systems, a path is absolute if it starts
* with a "/".
*
* @return true if this object represents an absolute file name, false otherwise.
*/
public boolean
isAbsolute()
{
if (path.startsWith(separator))
return(true);
else
return(false);
}
/*************************************************************************/
/**
* This method tests whether or not the current thread is allowed to
* to read the file pointed to by this object. This will be true if and
* and only if 1) the file exists and 2) the SecurityManager
* (if any) allows access to the file via it's checkRead
* method 3) the file is readable.
*
* @return true if reading is allowed, false otherwise
*
* @exception SecurityException If the SecurityManager does not allow access to the file
*/
public boolean
canRead() throws SecurityException
{
// Test for existence. This also does the SecurityManager check
if (!exists())
return(false);
return(canReadInternal(path));
}
/*************************************************************************/
/**
* This native method checks file permissions for reading
*/
private synchronized native boolean canReadInternal(String path);
/*************************************************************************/
/**
* This method test whether or not the current thread is allowed to
* write to this object. This will be true if and only if 1) The
* SecurityManager (if any) allows write access to the
* file and 2) The file exists and 3) The file is writable. To determine
* whether or not a non-existent file can be created, check the parent
* directory for write access.
*
* @return true if writing is allowed, false otherwise
*
* @exception SecurityException If the SecurityManager does not allow access to the file
*/
public boolean
canWrite() throws SecurityException
{
// Test for existence. This is required by the spec
if (!exists())
return(false);
// We still need to do a SecurityCheck since exists() only checks
// for read access
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkWrite(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
return(canWriteInternal(path));
}
/*************************************************************************/
/**
* This native method checks file permissions for writing
*/
private synchronized native boolean canWriteInternal(String path);
/*************************************************************************/
/**
* This method sets the file represented by this object to be read only.
* A read only file or directory cannot be modified. Please note that
* GNU systems allow read only files to be deleted if the directory it
* is contained in is writable.
*
* @return true if the operation succeeded, false
* otherwise.
*
* @exception SecurityException If the SecurityManager does
* not allow this operation.
*/
public boolean
setReadOnly() throws SecurityException
{
// Test for existence.
if (!exists())
return(false);
// We still need to do a SecurityCheck since exists() only checks
// for read access
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkWrite(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
return(setReadOnlyInternal(path));
}
/*************************************************************************/
/*
* This native method sets the permissions to make the file read only.
*/
private native boolean setReadOnlyInternal(String path);
/*************************************************************************/
/**
* This method tests whether or not the file represented by the object
* actually exists on the filesystem.
*
* @return true if the file exists, falseotherwise.
*
* @exception SecurityException If reading of the file is not permitted
*/
public boolean
exists() throws SecurityException
{
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkRead(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
return(existsInternal(path));
}
/*************************************************************************/
/**
* This native method does the actual checking of file existence.
*/
private native boolean existsInternal(String path);
/*************************************************************************/
/**
* This method tests whether or not the file represented by this object
* is a "plain" file. A file is a plain file if and only if it 1) Exists,
* 2) Is not a directory or other type of special file.
*
* @return true if this is a plain file, false otherwise
*
* @exception SecurityException If reading of the file is not permitted
*/
public boolean isFile() throws SecurityException
{
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkRead(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
return(isFileInternal(path));
}
/*************************************************************************/
/**
* This native method does the actual check of whether or not a file
* is a plain file or not. It also handles the existence check to
* eliminate the overhead of a call to exists()
*/
private native boolean isFileInternal(String path);
/*************************************************************************/
/**
* This method tests whether or not the file represented by this object
* is a directory. In order for this method to return true,
* the file represented by this object must exist and be a directory.
*
* @return true if this file is a directory, false otherwise
*
* @exception SecurityException If reading of the file is not permitted
*/
public boolean isDirectory() throws SecurityException
{
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkRead(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
return(isDirectoryInternal(path));
}
/*************************************************************************/
/**
* This method does the actual check of whether or not a file is a
* directory or not. It also handle the existence check to eliminate
* the overhead of a call to exists()
*/
private native boolean isDirectoryInternal(String path);
/*************************************************************************/
/**
* This method tests whether or not this file represents a "hidden" file.
* On GNU systems, a file is hidden if its name begins with a "."
* character. Files with these names are traditionally not shown with
* directory listing tools.
*
* @return true if the file is hidden, false
* otherwise.
*/
public boolean
isHidden()
{
if (getName().startsWith("."))
return(true);
else
return(false);
}
/*************************************************************************/
/**
* This method returns the length of the file represented by this object,
* or 0 if the specified file does not exist.
*
* @return The length of the file
*
* @exception SecurityException If reading of the file is not permitted
*/
public long
length() throws SecurityException
{
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkRead(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
return(lengthInternal(path));
}
/*************************************************************************/
/**
* This native method actually determines the length of the file and
* handles the existence check
*/
private native long lengthInternal(String path);
/*************************************************************************/
/**
* This method returns the last modification time of this file. The
* time value returned is an abstract value that should not be interpreted
* as a specified time value. It is only useful for comparing to other
* such time values returned on the same system. In that case, the larger
* value indicates a more recent modification time.
*
* If the file does not exist, then a value of 0 is returned.
*
* @return The last modification time of the file
*
* @exception SecurityException If reading of the file is not permitted
*/
public long
lastModified() throws SecurityException
{
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkRead(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
return(lastModifiedInternal(path));
}
/*************************************************************************/
/**
* This native method does the actual work of getting the last file
* modification time. It also does the existence check to avoid the
* overhead of a call to exists()
*/
private native long lastModifiedInternal(String path);
/*************************************************************************/
/**
* This method sets the modification time on the file to the specified
* value. This is specified as the number of seconds since midnight
* on January 1, 1970 GMT.
*
* @param time The desired modification time.
*
* @return true if the operation succeeded, false
* otherwise.
*
* @exception IlegalArgumentException If the specified time is negative.
* @exception SecurityException If the SecurityManager will
* not allow this operation.
*/
public boolean
setLastModified(long time) throws IllegalArgumentException, SecurityException
{
if (time < 0)
throw new IllegalArgumentException("Negative modification time: " + time);
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkWrite(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
return(setLastModifiedInternal(path, time));
}
/*************************************************************************/
/*
* This method does the actual setting of the modification time.
*/
private native boolean setLastModifiedInternal(String path, long time);
/*************************************************************************/
/**
* This method creates a new file of zero length with the same name as
* the path of this File object if an only if that file
* does not already exist.
*
* A SecurityManagercheckWrite check is done prior
* to performing this action.
*
* @return true if the file was created, false if
* the file alread existed.
*
* @exception IOException If an I/O error occurs
* @exception SecurityException If the SecurityManager will
* not allow this operation to be performed.
*/
public boolean
createNewFile() throws IOException, SecurityException
{
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkWrite(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
return(createInternal(getPath()));
}
/*************************************************************************/
/**
* This method deletes the file represented by this object. If this file
* is a directory, it must be empty in order for the delete to succeed.
*
* @return true if the file was deleted, false otherwise
*
* @exception SecurityException If deleting of the file is not allowed
*/
public synchronized boolean
delete() throws SecurityException
{
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkDelete(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
return(deleteInternal(path));
}
/*************************************************************************/
/**
* This native method handles the actual deleting of the file
*/
private native boolean deleteInternal(String path);
/*************************************************************************/
/**
* Calling this method requests that the file represented by this object
* be deleted when the virtual machine exits. Note that this request cannot
* be cancelled. Also, it will only be carried out if the virtual machine
* exits normally.
*
* @exception SecurityException If deleting of the file is not allowed
*/
public void
deleteOnExit() throws SecurityException
{
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkDelete(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
// Sounds like we need to do some VM specific stuff here. We could delete
// the file in finalize() and set FinalizeOnExit to true, but delete on
// finalize != delete on exit and we should not be setting up system
// parameters without the user's knowledge.
//********IMPLEMENT ME!!!!!!***************
return;
}
/*************************************************************************/
/**
* This method creates a directory for the path represented by this object.
*
* @return true if the directory was created, false otherwise
*
* @exception SecurityException If write access is not allowed to this file
*/
public boolean
mkdir() throws SecurityException
{
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkWrite(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
String mk_path;
if (path.endsWith(separator) && !path.equals(separator))
mk_path = path.substring(0, path.length() - 1);
else
mk_path = path;
return(mkdirInternal(mk_path));
}
/*************************************************************************/
/**
* This native method actually creates the directory
*/
private native boolean mkdirInternal(String path);
/*************************************************************************/
/**
* This method creates a directory for the path represented by this file.
* It will also create any intervening parent directories if necessary.
*
* @return true if the directory was created, false otherwise
*
* @exception SecurityException If write access is not allowed to this file
*/
public boolean
mkdirs() throws SecurityException
{
String parent = getParent();
if (parent == null)
{
return(mkdir());
}
File f = new File(parent);
if (!f.exists())
{
boolean rc = f.mkdirs();
if (rc == false)
return(false);
}
return(mkdir());
}
/*************************************************************************/
/**
* This method renames the file represented by this object to the path
* of the file represented by the argument File.
*
* @param dest The File object representing the target name
*
* @return true if the rename succeeds, false otherwise.
*
* @exception SecurityException If write access is not allowed to the file by the SecurityMananger.
*/
public synchronized boolean
renameTo(File dest) throws SecurityException
{
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkWrite(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
// Call our native rename method
boolean rc = renameToInternal(path, dest.getPath());
return(rc);
}
/*************************************************************************/
/**
* This native method actually performs the rename.
*/
private native boolean
renameToInternal(String target, String dest);
/*************************************************************************/
/**
* This method returns a array of String's representing the
* list of files is then directory represented by this object. If this
* object represents a non-directory file or a non-existent file, then
* null is returned. The list of files will not contain
* any names such as "." or ".." which indicate the current or parent
* directory. Also, the names are not guaranteed to be sorted.
*
* A SecurityManager check is made prior to reading the
* directory. If read access to the directory is denied, an exception
* will be thrown.
*
* @return An array of files in the directory, or null if this object does not represent a valid directory.
*
* @exception SecurityException If read access is not allowed to the directory by the SecurityManager
*/
public String[]
list()
{
return(list(null));
}
/*************************************************************************/
/**
* This method returns a array of String's representing the
* list of files is then directory represented by this object. If this
* object represents a non-directory file or a non-existent file, then
* null is returned. The list of files will not contain
* any names such as "." or ".." which indicate the current or parent
* directory. Also, the names are not guaranteed to be sorted.
*
* In this form of the list() method, a filter is specified
* that allows the caller to control which files are returned in the
* list. The FilenameFilter specified is called for each
* file returned to determine whether or not that file should be included
* in the list.
*
* A SecurityManager check is made prior to reading the
* directory. If read access to the directory is denied, an exception
* will be thrown.
*
* @param filter An object which will identify files to exclude from the directory listing.
*
* @return An array of files in the directory, or null if this object does not represent a valid directory.
*
* @exception SecurityException If read access is not allowed to the directory by the SecurityManager
*/
public String[]
list(FilenameFilter filter)
{
// Check the SecurityManager
SecurityManager sm = System.getSecurityManager();
if (sm != null)
{
// try
// {
sm.checkRead(path);
// }
// catch(AccessControlException e)
// {
// throw new SecurityException(e.getMessage())
// }
}
// Get the list of files
String list_path;
if (path.endsWith(separator) && !path.equals(separator))
list_path = path.substring(0, path.length() - 1);
else
list_path = path;
String files[] = listInternal(list_path);
if (files == null)
return(null);
if (filter == null)
return(files);
// Apply the filter
int count = 0;
for (int i = 0; i < files.length; i++)
{
if (filter.accept(this, files[i]))
++count;
else
files[i] = null;
}
String[] retfiles = new String[count];
count = 0;
for (int i = 0; i < files.length; i++)
if (files[i] != null)
retfiles[count++] = files[i];
return(retfiles);
}
/*************************************************************************/
/**
* This native function actually produces the list of file in this
* directory
*/
private native String[] listInternal(String dirname);
/*************************************************************************/
/**
* This method returns an array of File objects representing
* all the files in the directory represented by this object. If this
* object does not represent a directory, null is returned.
* Each of the returned File object is constructed with this
* object as its parent.
*
* A SecurityManager check is made prior to reading the
* directory. If read access to the directory is denied, an exception
* will be thrown.
*
* @return An array of File objects for this directory.
*
* @exception SecurityException If the SecurityManager denies
* access to this directory.
*/
public File[]
listFiles()
{
return(listFiles((FilenameFilter)null));
}
/*************************************************************************/
/**
* This method returns an array of File objects representing
* all the files in the directory represented by this object. If this
* object does not represent a directory, null is returned.
* Each of the returned File object is constructed with this
* object as its parent.
*
* In this form of the listFiles() method, a filter is specified
* that allows the caller to control which files are returned in the
* list. The FilenameFilter specified is called for each
* file returned to determine whether or not that file should be included
* in the list.
*
* A SecurityManager check is made prior to reading the
* directory. If read access to the directory is denied, an exception
* will be thrown.
*
* @return An array of File objects for this directory.
*
* @exception SecurityException If the SecurityManager denies
* access to this directory.
*/
public File[]
listFiles(FilenameFilter filter)
{
String[] filelist = list(filter);
File[] fobjlist = new File[filelist.length];
for (int i = 0; i < filelist.length; i++)
fobjlist[i] = new File(this, filelist[i]);
return(fobjlist);
}
/*************************************************************************/
/**
* This method returns an array of File objects representing
* all the files in the directory represented by this object. If this
* object does not represent a directory, null is returned.
* Each of the returned File object is constructed with this
* object as its parent.
*
* In this form of the listFiles() method, a filter is specified
* that allows the caller to control which files are returned in the
* list. The FileFilter specified is called for each
* file returned to determine whether or not that file should be included
* in the list.
*
* A SecurityManager check is made prior to reading the
* directory. If read access to the directory is denied, an exception
* will be thrown.
*
* @return An array of File objects for this directory.
*
* @exception SecurityException If the SecurityManager denies
* access to this directory.
*/
public File[]
listFiles(FileFilter filter)
{
File[] fobjlist = listFiles((FilenameFilter)null);
int count = 0;
for (int i = 0; i < fobjlist.length; i++)
if (filter.accept(fobjlist[i]) == true)
++count;
File[] final_list = new File[count];
count = 0;
for (int i = 0; i < fobjlist.length; i++)
if (filter.accept(fobjlist[i]) == true)
{
final_list[count] = fobjlist[i];
++count;
}
return(final_list);
}
/*************************************************************************/
/**
* This method compares the specified Object to this one
* to test for equality. It does this by comparing the canonical path names
* of the files. This method is identical to compareTo(File)
* except that if the Object passed to it is not a
* File, it throws a ClassCastException
*
* The canonical paths of the files are determined by calling the
* getCanonicalPath method on each object.
*
* This method returns a 0 if the specified Object is equal
* to this one, a negative value if it is less than this one
* a positive value if it is greater than this one.
*
* @return An integer as described above
*
* @exception ClassCastException If the passed Object is not a File
*/
public int
compareTo(Object obj) throws ClassCastException
{
return(compareTo((File)obj));
}
/*************************************************************************/
/**
* This method compares the specified File to this one
* to test for equality. It does this by comparing the canonical path names
* of the files.
*
* The canonical paths of the files are determined by calling the
* getCanonicalPath method on each object.
*
* This method returns a 0 if the specified Object is equal
* to this one, a negative value if it is less than this one
* a positive value if it is greater than this one.
*
* @return An integer as described above
*/
public int
compareTo(File file)
{
String p1, p2;
try
{
p1 = getCanonicalPath();
p2 = file.getCanonicalPath();
}
catch(IOException e)
{
// What do we do here? The spec requires the canonical path. Even
// if we don't call the method, we must replicate the functionality
// which per the spec can fail. What happens in that situation?
// I just assume the files are equal!
//
return(0);
}
return(p1.compareTo(p2));
}
/*************************************************************************/
/**
* This method tests two File objects for equality by
* comparing the path of the specified File against the path
* of this object. The two objects are equal if an only if 1) The
* argument is not null 2) The argument is a File object and
* 3) The path of the Fileargument is equal to the path
* of this object.
*
* The paths of the files are determined by calling the getPath()
* method on each object.
*
* @return true if the two objects are equal, false otherwise.
*/
public boolean
equals(Object obj)
{
if (obj == null)
return(false);
if (!(obj instanceof File))
return(false);
File f = (File)obj;
return(f.getPath().equals(getPath()));
}
/*************************************************************************/
/**
* This method returns a hash code representing this file. It is the
* hash code of the path of this file (as returned by getPath())
* exclusived or-ed with the value 1234321.
*
* @return The hash code for this object
*/
public int
hashCode()
{
return(getPath().hashCode() ^ 1234321);
}
/*************************************************************************/
/**
* This method returns a String that is the path name of the
* file as returned by getPath.
*
* @return A String representation of this file
*/
public String
toString()
{
return(path);
}
/*************************************************************************/
/**
* This method returns a URL with the file:
* protocol that represents this file. The exact form of this URL is
* system dependent.
*
* @return A URL for this object.
*
* @exception MalformedURLException If the URL cannot be created successfully.
*/
public URL
toURL() throws MalformedURLException
{
String url_string = "file://" + getAbsolutePath();
return(new URL(url_string));
}
} // class File