home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / Main.bin / File.java < prev    next >
Encoding:
Java Source  |  1998-09-22  |  25.3 KB  |  687 lines
  1. /*
  2.  * @(#)File.java    1.52 98/07/01
  3.  *
  4.  * Copyright 1995-1998 by Sun Microsystems, Inc.,
  5.  * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
  6.  * All rights reserved.
  7.  * 
  8.  * This software is the confidential and proprietary information
  9.  * of Sun Microsystems, Inc. ("Confidential Information").  You
  10.  * shall not disclose such Confidential Information and shall use
  11.  * it only in accordance with the terms of the license agreement
  12.  * you entered into with Sun.
  13.  */
  14.  
  15. package java.io;
  16.  
  17. import java.util.Vector;
  18.  
  19. /**
  20.  * Instances of this class represent the name of a file or directory 
  21.  * on the host file system. A file is specified by a pathname, which 
  22.  * can either be an absolute pathname or a pathname relative to the 
  23.  * current working directory. The pathname must follow the naming 
  24.  * conventions of the host platform. 
  25.  * <p>
  26.  * The <code>File</code> class is intended to provide an abstraction 
  27.  * that deals with most of the machine dependent complexities of 
  28.  * files and pathnames in a machine-independent fashion. 
  29.  * <p>
  30.  * Note that whenever a filename or path is used it is
  31.  * assumed that the host's file naming conventions are used.
  32.  *
  33.  * @version 1.52, 07/01/98
  34.  * @author  Arthur van Hoff
  35.  * @author  Jonathan Payne
  36.  * @since   JDK1.0
  37.  */
  38. public
  39. class File implements java.io.Serializable {
  40.     /**
  41.      * The path of the file. The host's file separator is used.
  42.      */
  43.     private String path;
  44.  
  45.     /**
  46.      * The system-dependent path separator string. This field is 
  47.      * initialized to contain the value of the system property 
  48.      * <code>file.separator</code>. 
  49.      *
  50.      * @see     java.lang.System#getProperty(java.lang.String)
  51.      * @since   JDK1.0
  52.      */
  53.     public static final String separator = System.getProperty("file.separator");
  54.  
  55.     /**
  56.      * The system-dependent path separator character. This field is 
  57.      * initialized to contain the first character of the value of the 
  58.      * system property <code>file.separator</code>. This character 
  59.      * separates the directory and file components in a filename. 
  60.      *
  61.      * @see     java.lang.System#getProperty(java.lang.String)
  62.      * @since   JDK1.0
  63.      */
  64.     public static final char separatorChar = separator.charAt(0);
  65.     
  66.     /**
  67.      * The system-dependent path separator string. This field is 
  68.      * initialized to contain the value of the system property 
  69.      * <code>path.separator</code>. 
  70.      *
  71.      * @see     java.lang.System#getProperty(java.lang.String)
  72.      * @since   JDK1.0
  73.      */
  74.     public static final String pathSeparator = System.getProperty("path.separator");
  75.  
  76.     /**
  77.      * The system-dependent path separator character. This field is 
  78.      * initialized to contain the first character of the value of the 
  79.      * system property <code>path.separator</code>. This character is 
  80.      * often used to separate filenames in a sequence of files given as a 
  81.      * "path list".
  82.      *
  83.      * @see     java.lang.System#getProperty(java.lang.String)
  84.      * @since   JDK1.0
  85.      */
  86.     public static final char pathSeparatorChar = pathSeparator.charAt(0);
  87.     
  88.     /**
  89.      * Creates a <code>File</code> instance that represents the file 
  90.      * whose pathname is the given path argument. 
  91.      *
  92.      * @param      path   the file pathname.
  93.      * @exception  NullPointerException  if the file path is equal to
  94.      *               <code>null</code>.
  95.      * @see        java.io.File#getPath()
  96.      * @since      JDK1.0
  97.      */
  98.     public File(String path) {
  99.     if (path == null) {
  100.         throw new NullPointerException();
  101.     }
  102.     this.path = path;
  103.     }    
  104.  
  105.     /**
  106.      * Creates a <code>File</code> instance whose pathname is the 
  107.      * pathname of the specified directory, followed by the separator 
  108.      * character, followed by the <code>name</code> argument. 
  109.      *
  110.      * @param   path   the directory pathname.
  111.      * @param   name   the file pathname.
  112.      * @see     java.io.File#getPath()
  113.      * @see     java.io.File#separator
  114.      * @since   JDK1.0
  115.      */
  116.     public File(String path, String name) {
  117.     if (name == null) {
  118.         /* raise exception, per Java Language Spec
  119.          * 22.24.6 & 22.24.7
  120.          */
  121.         throw new NullPointerException();
  122.     }
  123.     if (path != null) {
  124.         if (path.endsWith(separator)) {
  125.         this.path = path + name;
  126.         } else {
  127.         this.path = path + separator + name;
  128.         } 
  129.     } else {
  130.         this.path = name;
  131.     }
  132.     }
  133.  
  134.     /**
  135.      * Creates a <code>File</code> instance that represents the file 
  136.      * with the specified name in the specified directory. 
  137.      * <p>
  138.      * If the directory argument is <code>null</code>, the resulting 
  139.      * <code>File</code> instance represents a file in the 
  140.      * (system-dependent) current directory whose pathname is the 
  141.      * <code>name</code> argument. Otherwise, the <code>File</code> 
  142.      * instance represents a file whose pathname is the pathname of the 
  143.      * directory, followed by the separator character, followed by the 
  144.      * <code>name</code> argument. 
  145.      *
  146.      * @param   dir   the directory.
  147.      * @param   name   the file pathname.
  148.      * @see     java.io.File#getPath()
  149.      * @see     java.io.File#separator
  150.      * @since   JDK1.0
  151.      */
  152.     public File(File dir, String name) {
  153.     this(dir.getPath(), name);
  154.     }
  155.  
  156.     /**
  157.      * Returns the name of the file represented by this object. The name 
  158.      * is everything in the pathame after the last occurrence of the 
  159.      * separator character. 
  160.      *
  161.      * @return  the name of the file (without any directory components)
  162.      *          represented by this <code>File</code> object.
  163.      * @see     java.io.File#getPath()
  164.      * @see     java.io.File#separator
  165.      * @since   JDK1.0
  166.      */
  167.     public String getName() {
  168.     int index = path.lastIndexOf(separatorChar);
  169.     return (index < 0) ? path : path.substring(index + 1);
  170.     }
  171.  
  172.     /**
  173.      * Returns the pathname of the file represented by this object.
  174.      *
  175.      * @return  the pathname represented by this <code>File</code> object.
  176.      * @since   JDK1.0
  177.      */
  178.     public String getPath() {
  179.     return path;
  180.     }
  181.  
  182.     /**
  183.      * Returns the absolute pathname of the file represented by this object.
  184.      * If this object represents an absolute pathname, then return the 
  185.      * pathname. Otherwise, return a pathname that is a concatenation of 
  186.      * the current user directory, the separator character, and the 
  187.      * pathname of this file object. 
  188.      * <p>
  189.      * The system property <code>user.dir</code> contains the current 
  190.      * user directory. 
  191.      *
  192.      * @return  a system-dependent absolute pathname for this <code>File</code>.
  193.      * @see     java.io.File#getPath()
  194.      * @see     java.io.File#isAbsolute()
  195.      * @see     java.lang.System#getProperty(java.lang.String)
  196.      * @since   JDK1.0
  197.      */
  198.     public String getAbsolutePath() {
  199.     if (isAbsolute())
  200.         return path;
  201.  
  202.     SecurityManager security = System.getSecurityManager();
  203.     if (security != null) {
  204.         security.checkPropertyAccess("user.dir");
  205.     }
  206.     return System.getProperty("user.dir") + separator + path;
  207.     }
  208.  
  209.     /**
  210.      * Returns the canonical form of this <code>File</code> object's pathname.
  211.      * The precise definition of canonical form is system-dependent, but it
  212.      * usually specifies an absolute pathname in which all relative references
  213.      * and references to the current user directory have been completely
  214.      * resolved.  The canonical form of a pathname of a nonexistent file may
  215.      * not be defined.
  216.      *
  217.      * @exception IOException If an I/O error occurs, which is possible because
  218.      * the construction of the canonical path may require filesystem queries.
  219.      *
  220.      * @since   JDK1.1
  221.      */
  222.      public String getCanonicalPath() throws IOException {
  223.     if (isAbsolute())
  224.         return canonPath(path);
  225.  
  226.     SecurityManager security = System.getSecurityManager();
  227.     if (security != null) {
  228.         security.checkPropertyAccess("user.dir");
  229.     }
  230.     return canonPath(System.getProperty("user.dir") + separator + path);
  231.     }
  232.  
  233.     /**
  234.      * Returns the parent part of the pathname of this <code>File</code>
  235.      * object, or <code>null</code> if the name has no parent part.  The parent
  236.      * part is generally everything leading up to the last occurrence of the
  237.      * separator character, although the precise definition is system
  238.      * dependent.  On UNIX, for example, the parent part of
  239.      * <code>"/usr/lib"</code> is <code>"/usr"</code>, whose parent part is
  240.      * <code>"/"</code>, which in turn has no parent.  On Windows platforms,
  241.      * the parent part of <code>"c:\java"</code> is <code>"c:\"</code>, which
  242.      * in turn has no parent.
  243.      *
  244.      * @see     java.io.File#getPath()
  245.      * @see     java.io.File#getCanonicalPath()
  246.      * @see     java.io.File#separator
  247.      * @since   JDK1.0
  248.      */
  249.     public String getParent() {
  250.     /* This is correct for Unix and Win32; other platforms may require a
  251.            different algorithm */
  252.     int index = path.lastIndexOf(separatorChar);
  253.     if (index < 0)
  254.         return null;
  255.     if (!isAbsolute() || (path.indexOf(separatorChar) != index))
  256.         return path.substring(0, index);
  257.     if (index < path.length() - 1)
  258.         return path.substring(0, index + 1);
  259.     return null;
  260.     }
  261.  
  262.     private native boolean exists0();
  263.     private native boolean canWrite0();
  264.     private native boolean canRead0();
  265.     private native boolean isFile0();
  266.     private native boolean isDirectory0();
  267.     private native long lastModified0();
  268.     private native long length0();
  269.     private native boolean mkdir0();
  270.     private native boolean renameTo0(File dest);
  271.     private native boolean delete0();
  272.     private native boolean rmdir0(); // remove empty directory
  273.     private native String[] list0();
  274.     private native String canonPath(String p) throws IOException;
  275.  
  276.     /**
  277.      * Tests if this <code>File</code> exists. 
  278.      *
  279.      * @return     <code>true</code> if the file specified by this object
  280.      *             exists; <code>false</code> otherwise.
  281.      * @exception  SecurityException  if a security manager exists, its
  282.      *               <code>checkRead</code> method is called with the pathname
  283.      *               of this <code>File</code> to see if the application is
  284.      *               allowed read access to the file.
  285.      * @see        java.io.File#getPath()
  286.      * @see        java.lang.SecurityManager#checkRead(java.lang.String)
  287.      * @since      JDK1.0
  288.      */
  289.     public boolean exists() {
  290.     SecurityManager security = System.getSecurityManager();
  291.     if (security != null) {
  292.         security.checkRead(path);
  293.     }
  294.     return exists0();
  295.     }
  296.  
  297.     /**
  298.      * Tests if the application can write to this file. 
  299.      *
  300.      * @return     <code>true</code> if the application is allowed to write to
  301.      *             a file whose name is specified by this object;
  302.      *            <code>false</code> otherwise.
  303.      * @exception  SecurityException  if a security manager exists, its
  304.      *               <code>checkWrite</code> method is called with the pathname
  305.      *               of this <code>File</code> to see if the application is
  306.      *               allowed write access to the file.
  307.      * @see        java.io.File#getPath()
  308.      * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
  309.      * @since      JDK1.0
  310.      */
  311.     public boolean canWrite() {
  312.     SecurityManager security = System.getSecurityManager();
  313.     if (security != null) {
  314.         security.checkWrite(path);
  315.     }
  316.     return canWrite0();
  317.     }
  318.  
  319.     /**
  320.      * Tests if the application can read from the specified file. 
  321.      *
  322.      * @return     <code>true</code> if the file specified by this object exists
  323.      *             and the application can read the file;
  324.      *             <code>false</code> otherwise.
  325.      * @exception  SecurityException  if a security manager exists, its
  326.      *               <code>checkRead</code> method is called with the pathname
  327.      *               of this <code>File</code> to see if the application is
  328.      *               allowed read access to the file.
  329.      * @see        java.io.File#getPath()
  330.      * @see        java.lang.SecurityManager#checkRead(java.lang.String)
  331.      * @since      JDK1.0
  332.      */
  333.     public boolean canRead() {
  334.     SecurityManager security = System.getSecurityManager();
  335.     if (security != null) {
  336.         security.checkRead(path);
  337.     }
  338.     return canRead0();
  339.     }
  340.  
  341.     /**
  342.      * Tests if the file represented by this <code>File</code> 
  343.      * object is a "normal" file. 
  344.      * <p>
  345.      * A file is "normal" if it is not a directory and, in 
  346.      * addition, satisfies other system-dependent criteria. Any 
  347.      * non-directory file created by a Java application is guaranteed to 
  348.      * be a normal file. 
  349.      *
  350.      * @return     <code>true</code> if the file specified by this object
  351.      *             exists and is a "normal" file; <code>false</code> otherwise.
  352.      * @exception  SecurityException  If a security manager exists, its
  353.      *               <code>checkRead</code> method is called with the pathname
  354.      *               of this <code>File</code> to see if the application is
  355.      *               allowed read access to the file.
  356.      * @see        java.io.File#getPath()
  357.      * @see        java.lang.SecurityManager#checkRead(java.lang.String)
  358.      * @since      JDK1.0
  359.      */
  360.     public boolean isFile() {
  361.     SecurityManager security = System.getSecurityManager();
  362.     if (security != null) {
  363.         security.checkRead(path);
  364.     }
  365.     return isFile0();
  366.     }
  367.  
  368.     /**
  369.      * Tests if the file represented by this <code>File</code> 
  370.      * object is a directory. 
  371.      *
  372.      * @return     <code>true</code> if this <code>File</code> exists and is a
  373.      *             directory; <code>false</code> otherwise.
  374.      * @exception  SecurityException  if a security manager exists, its
  375.      *               <code>checkRead</code> method is called with the pathname
  376.      *               of this <code>File</code> to see if the application is
  377.      *               allowed read access to the file.
  378.      * @see        java.io.File#getPath()
  379.      * @see        java.lang.SecurityManager#checkRead(java.lang.String)
  380.      * @since      JDK1.0
  381.      */
  382.     public boolean isDirectory() {
  383.     SecurityManager security = System.getSecurityManager();
  384.     if (security != null) {
  385.         security.checkRead(path);
  386.     }
  387.     return isDirectory0();
  388.     }
  389.  
  390.     /**
  391.      * Tests if the file represented by this <code>File</code> object is an
  392.      * absolute pathname. The definition of an absolute pathname is system 
  393.      * dependent. For example, on UNIX, a pathname is absolute if its 
  394.      * first character is the separator character. On Windows platforms, 
  395.      * a pathname is absolute if its first character is an ASCII '\' or 
  396.      * '/', or if it begins with a letter followed by a colon. 
  397.      *
  398.      * @return  <code>true</code> if the pathname indicated by the
  399.      *          <code>File</code> object is an absolute pathname;
  400.      *          <code>false</code> otherwise.
  401.      * @see     java.io.File#getPath()
  402.      * @see     java.io.File#separator
  403.      * @since   JDK1.0
  404.      */
  405.     public native boolean isAbsolute();
  406.  
  407.     /**
  408.      * Returns the time that the file represented by this 
  409.      * <code>File</code> object was last modified. 
  410.      * <p>
  411.      * The return value is system dependent and should only be used to 
  412.      * compare with other values returned by last modified. It should not 
  413.      * be interpreted as an absolute time. 
  414.      *
  415.      * @return     the time the file specified by this object was last modified,
  416.      *             or <code>0L</code> if the specified file does not exist.
  417.      * @exception  SecurityException  if a security manager exists, its
  418.      *               <code>checkRead</code> method is called with the pathname
  419.      *               of this <code>File</code> to see if the application is
  420.      *               allowed read access to the file.
  421.      * @see        java.io.File#getPath()
  422.      * @see        java.lang.SecurityManager#checkRead(java.lang.String)
  423.      * @since      JDK1.0
  424.      */
  425.     public long lastModified() {
  426.     SecurityManager security = System.getSecurityManager();
  427.     if (security != null) {
  428.         security.checkRead(path);
  429.     }
  430.     return lastModified0();
  431.     }
  432.  
  433.     /**
  434.      * Returns the length of the file represented by this 
  435.      * <code>File</code> object. 
  436.      *
  437.      * @return     the length, in bytes, of the file specified by this object,
  438.      *             or <code>0L</code> if the specified file does not exist.
  439.      * @exception  SecurityException  if a security manager exists, its
  440.      *               <code>checkRead</code> method is called with the pathname
  441.      *               of this <code>File</code> to see if the application is
  442.      *               allowed read access to the file.
  443.      * @see        java.io.File#getPath()
  444.      * @see        java.lang.SecurityManager#checkRead(java.lang.String)
  445.      * @since      JDK1.0
  446.      */
  447.     public long length() {
  448.     SecurityManager security = System.getSecurityManager();
  449.     if (security != null) {
  450.         security.checkRead(path);
  451.     }
  452.     return length0();
  453.     }
  454.  
  455.     /**
  456.      * Creates a directory whose pathname is specified by this 
  457.      * <code>File</code> object. 
  458.      *
  459.      * @return     <code>true</code> if the directory could be created;
  460.      *             <code>false</code> otherwise.
  461.      * @exception  SecurityException  if a security manager exists, its
  462.      *               <code>checkWrite</code> method is called with the pathname
  463.      *               of this <code>File</code> to see if the application is
  464.      *               allowed write access to the file.
  465.      * @see        java.io.File#getPath()
  466.      * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
  467.      * @since      JDK1.0
  468.      */
  469.     public boolean mkdir() {
  470.     SecurityManager security = System.getSecurityManager();
  471.     if (security != null) {
  472.         security.checkWrite(path);
  473.     }
  474.     return mkdir0();
  475.     }
  476.  
  477.     /**
  478.      * Renames the file specified by this <code>File</code> object to 
  479.      * have the pathname given by the <code>File</code> argument. 
  480.      *
  481.      * @param      dest   the new filename.
  482.      * @return     <code>true</code> if the renaming succeeds;
  483.      *             <code>false</code> otherwise.
  484.      * @exception  SecurityException  if a security manager exists, its
  485.      *               <code>checkWrite</code> method is called both with the
  486.      *               pathname of this file object and with the pathname of the
  487.      *               destination target object to see if the application is
  488.      *               allowed to write to both files.
  489.      * @see        java.io.File#getPath()
  490.      * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
  491.      * @since      JDK1.0
  492.      */
  493.     public boolean renameTo(File dest) {
  494.     SecurityManager security = System.getSecurityManager();
  495.     if (security != null) {
  496.         security.checkWrite(path);
  497.         security.checkWrite(dest.path);
  498.     }
  499.     return renameTo0(dest);
  500.     }
  501.  
  502.     /**
  503.      * Creates a directory whose pathname is specified by this 
  504.      * <code>File</code> object, including any necessary parent directories.
  505.      *
  506.      * @return     <code>true</code> if the directory (or directories) could be
  507.      *             created; <code>false</code> otherwise.
  508.      * @exception  SecurityException  if a security manager exists, its
  509.      *               <code>checkWrite</code> method is called with the pathname
  510.      *               of each of the directories that is to be created, before
  511.      *               any of the directories are created.
  512.      * @see        java.io.File#getPath()
  513.      * @see        java.lang.SecurityManager#checkWrite(java.lang.String)
  514.      * @since      JDK1.0
  515.      */
  516.     public boolean mkdirs() {
  517.     if(exists()) {
  518.         return false;
  519.     }
  520.     if (mkdir()) {
  521.          return true;
  522.      }
  523.  
  524.     String parent = getParent();
  525.     return (parent != null) && (new File(parent).mkdirs() && mkdir());
  526.     }
  527.  
  528.     /**
  529.      * Returns a list of the files in the directory specified by this
  530.      * <code>File</code> object. 
  531.      *
  532.      * @return     an array of file names in the specified directory.
  533.      *             This list does not include the current directory or the
  534.      *             parent directory ("<code>.</code>" and "<code>..</code>"
  535.      *             on Unix systems).
  536.      * @exception  SecurityException  If a security manager exists, its
  537.      *               <code>checkRead</code> method is called with the pathname
  538.      *               of this <code>File</code> to see if the application is
  539.      *               allowed read access to the file.
  540.      * @see        java.io.File#getPath()
  541.      * @see        java.lang.SecurityManager#checkRead(java.lang.String)
  542.      * @since      JDK1.0
  543.      */
  544.     public String[] list() {
  545.     SecurityManager security = System.getSecurityManager();
  546.     if (security != null) {
  547.         security.checkRead(path);
  548.     }
  549.     return list0();
  550.     }
  551.  
  552.     /**
  553.      * Returns a list of the files in the directory specified by this 
  554.      * <code>File</code> that satisfy the specified filter. 
  555.      *
  556.      * @param      filter   a filename filter.
  557.      * @return     an array of file names in the specified directory.
  558.      *             This list does not include the current directory or the
  559.      *             parent directory ("<code>.</code>" and "<code>..</code>"
  560.      *             on Unix systems).
  561.      * @exception  SecurityException  If a security manager exists, its
  562.      *               <code>checkRead</code> method is called with the pathname
  563.      *               of this <code>File</code> to see if the application is
  564.      *               allowed read access to the file.
  565.      * @see        java.io.File#getPath()
  566.      * @see        java.io.FilenameFilter
  567.      * @see        java.lang.SecurityManager#checkRead(java.lang.String)
  568.      * @since      JDK1.0
  569.      */
  570.     public String[] list(FilenameFilter filter) {
  571.     String names[] = list();
  572.  
  573.     if (names == null) {
  574.         return null;
  575.     }
  576.  
  577.     // Fill in the Vector
  578.     Vector v = new Vector();
  579.     for (int i = 0 ; i < names.length ; i++) {
  580.         if ((filter == null) || filter.accept(this, names[i])) {
  581.         v.addElement(names[i]);
  582.         }
  583.     }
  584.  
  585.     // Create the array
  586.     String files[] = new String[v.size()];
  587.     v.copyInto(files);
  588.  
  589.     return files;
  590.     }
  591.  
  592.     /**
  593.      * Deletes the file specified by this object.  If the target
  594.      * file to be deleted is a directory, it must be empty for deletion
  595.      * to succeed.
  596.      *
  597.      * @return     <code>true</code> if the file is successfully deleted;
  598.      *             <code>false</code> otherwise.
  599.      * @exception  SecurityException  if a security manager exists, its
  600.      *               <code>checkDelete</code> method is called with the
  601.      *               pathname of this <code>File</code> to see if the
  602.      *               application is allowed to delete the file.
  603.      * @see        java.io.File#getPath()
  604.      * @see        java.lang.SecurityManager#checkDelete(java.lang.String)
  605.      * @since      JDK1.0
  606.      */
  607.     public boolean delete() {
  608.     SecurityManager security = System.getSecurityManager();
  609.     if (security != null) {
  610.         security.checkDelete(path);
  611.     }
  612.     if(isDirectory())
  613.         return rmdir0();
  614.     else
  615.         return delete0();
  616.     }
  617.  
  618.     /**
  619.      * Computes a hashcode for the file.
  620.      *
  621.      * @return  a hash code value for this <code>File</code> object.
  622.      * @since   JDK1.0
  623.      */
  624.     public int hashCode() {
  625.     return path.hashCode() ^ 1234321;
  626.     }
  627.  
  628.     /**
  629.      * Compares this object against the specified object.
  630.      * Returns <code>true</code> if and only if the argument is 
  631.      * not <code>null</code> and is a <code>File</code> object whose 
  632.      * pathname is equal to the pathname of this object. 
  633.      *
  634.      * @param   obj   the object to compare with.
  635.      * @return  <code>true</code> if the objects are the same;
  636.      *          <code>false</code> otherwise.
  637.      * @since   JDK1.0
  638.      */
  639.     public boolean equals(Object obj) {
  640.     if ((obj != null) && (obj instanceof File)) {
  641.         return path.equals(((File)obj).path);
  642.     }
  643.     return false;
  644.     }
  645.  
  646.     /**
  647.      * Returns a string representation of this object. 
  648.      *
  649.      * @return  a string giving the pathname of this object. 
  650.      * @see     java.io.File#getPath()
  651.      * @since   JDK1.0
  652.      */
  653.     public String toString() {
  654.     return getPath();
  655.     }
  656.  
  657.     /**
  658.      * WriteObject is called to save this filename.
  659.      * The separator character is saved also so it can be replaced
  660.      * in case the path is reconstituted on a different host type.
  661.      */
  662.     private synchronized void writeObject(java.io.ObjectOutputStream s)
  663.         throws IOException
  664.     {
  665.     s.defaultWriteObject();
  666.     s.writeChar(separatorChar); // Add the separator character
  667.     }
  668.  
  669.     /**
  670.      * readObject is called to restore this filename.
  671.      * The original separator character is read.  If it is different
  672.      * than the separator character on this system. The old seperator
  673.      * is replaced by the current separator.
  674.      */
  675.     private synchronized void readObject(java.io.ObjectInputStream s)
  676.          throws IOException, ClassNotFoundException
  677.     {
  678.     s.defaultReadObject();
  679.     char sep = s.readChar(); // read the previous seperator char
  680.     if (sep != separatorChar)
  681.         path = path.replace(sep, separatorChar);
  682.     }
  683.  
  684.     /** use serialVersionUID from JDK 1.0.2 for interoperability */
  685.     private static final long serialVersionUID = 301077366599181567L;
  686. }
  687.