protected FileUtils() 
{

}

Empty constructor.

 public static  void close(Writer device) 
{
        if (null != device) {
            try {
                device.close();
            } catch (IOException e) {
                //ignore
            }
        }
}

Close a Writer without throwing any exception if something went wrong. Do not attempt to close it if the argument is null.

 public static  void close(Reader device) 
{
        if (null != device) {
            try {
                device.close();
            } catch (IOException e) {
                //ignore
            }
        }
}

Close a Reader without throwing any exception if something went wrong. Do not attempt to close it if the argument is null.

 public static  void close(OutputStream device) 
{
        if (null != device) {
            try {
                device.close();
            } catch (IOException e) {
                //ignore
            }
        }
}

Close a stream without throwing any exception if something went wrong. Do not attempt to close it if the argument is null.

 public static  void close(InputStream device) 
{
        if (null != device) {
            try {
                device.close();
            } catch (IOException e) {
                //ignore
            }
        }
}

Close a stream without throwing any exception if something went wrong. Do not attempt to close it if the argument is null.

 public boolean contentEquals(File f1,
    File f2) throws IOException 
{
        return contentEquals(f1, f2, false);
}

Compares the contents of two files.

 public boolean contentEquals(File f1,
    File f2,
    boolean textfile) throws IOException 
{
        return ResourceUtils.contentEquals(new FileResource(f1), new FileResource(f2), textfile);
}

Compares the contents of two files.

 public  void copyFile(String sourceFile,
    String destFile) throws IOException 
{
        copyFile(new File(sourceFile), new File(destFile), null, false, false);
}

Convenience method to copy a file from a source to a destination. No filtering is performed.

 public  void copyFile(File sourceFile,
    File destFile) throws IOException 
{
        copyFile(sourceFile, destFile, null, false, false);
}

Convenience method to copy a file from a source to a destination. No filtering is performed.

 public  void copyFile(String sourceFile,
    String destFile,
    FilterSetCollection filters) throws IOException 
{
        copyFile(new File(sourceFile), new File(destFile), filters, false, false);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used.

 public  void copyFile(File sourceFile,
    File destFile,
    FilterSetCollection filters) throws IOException 
{
        copyFile(sourceFile, destFile, filters, false, false);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used.

 public  void copyFile(String sourceFile,
    String destFile,
    FilterSetCollection filters,
    boolean overwrite) throws IOException 
{
        copyFile(new File(sourceFile), new File(destFile), filters, overwrite, false);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used and if source files may overwrite newer destination files.

 public  void copyFile(File sourceFile,
    File destFile,
    FilterSetCollection filters,
    boolean overwrite) throws IOException 
{
        copyFile(sourceFile, destFile, filters, overwrite, false);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used and if source files may overwrite newer destination files.

 public  void copyFile(String sourceFile,
    String destFile,
    FilterSetCollection filters,
    boolean overwrite,
    boolean preserveLastModified) throws IOException 
{
        copyFile(new File(sourceFile), new File(destFile), filters, overwrite,
                 preserveLastModified);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used, if source files may overwrite newer destination files and the last modified time of destFile file should be made equal to the last modified time of sourceFile.

 public  void copyFile(File sourceFile,
    File destFile,
    FilterSetCollection filters,
    boolean overwrite,
    boolean preserveLastModified) throws IOException 
{
        copyFile(sourceFile, destFile, filters, overwrite, preserveLastModified, null);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used, if source files may overwrite newer destination files and the last modified time of destFile file should be made equal to the last modified time of sourceFile.

 public  void copyFile(String sourceFile,
    String destFile,
    FilterSetCollection filters,
    boolean overwrite,
    boolean preserveLastModified,
    String encoding) throws IOException 
{
        copyFile(new File(sourceFile), new File(destFile), filters,
                 overwrite, preserveLastModified, encoding);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used, if source files may overwrite newer destination files and the last modified time of destFile file should be made equal to the last modified time of sourceFile.

 public  void copyFile(File sourceFile,
    File destFile,
    FilterSetCollection filters,
    boolean overwrite,
    boolean preserveLastModified,
    String encoding) throws IOException 
{
        copyFile(sourceFile, destFile, filters, null, overwrite,
                 preserveLastModified, encoding, null);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used, if source files may overwrite newer destination files, the last modified time of destFile file should be made equal to the last modified time of sourceFile and which character encoding to assume.

 public  void copyFile(String sourceFile,
    String destFile,
    FilterSetCollection filters,
    Vector filterChains,
    boolean overwrite,
    boolean preserveLastModified,
    String encoding,
    Project project) throws IOException 
{
        copyFile(new File(sourceFile), new File(destFile), filters, filterChains, overwrite,
                preserveLastModified, encoding, project);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used, if filter chains must be used, if source files may overwrite newer destination files and the last modified time of destFile file should be made equal to the last modified time of sourceFile.

 public  void copyFile(File sourceFile,
    File destFile,
    FilterSetCollection filters,
    Vector filterChains,
    boolean overwrite,
    boolean preserveLastModified,
    String encoding,
    Project project) throws IOException 
{
        copyFile(sourceFile, destFile, filters, filterChains,
                 overwrite, preserveLastModified, encoding, encoding, project);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used, if filter chains must be used, if source files may overwrite newer destination files and the last modified time of destFile file should be made equal to the last modified time of sourceFile.

 public  void copyFile(String sourceFile,
    String destFile,
    FilterSetCollection filters,
    Vector filterChains,
    boolean overwrite,
    boolean preserveLastModified,
    String inputEncoding,
    String outputEncoding,
    Project project) throws IOException 
{
        copyFile(new File(sourceFile), new File(destFile), filters, filterChains, overwrite,
                preserveLastModified, inputEncoding, outputEncoding, project);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used, if filter chains must be used, if source files may overwrite newer destination files and the last modified time of destFile file should be made equal to the last modified time of sourceFile.

 public  void copyFile(File sourceFile,
    File destFile,
    FilterSetCollection filters,
    Vector filterChains,
    boolean overwrite,
    boolean preserveLastModified,
    String inputEncoding,
    String outputEncoding,
    Project project) throws IOException 
{
        ResourceUtils.copyResource(
            new FileResource(sourceFile), new FileResource(destFile),
            filters, filterChains, overwrite, preserveLastModified,
            inputEncoding, outputEncoding, project);
}

Convenience method to copy a file from a source to a destination specifying if token filtering must be used, if filter chains must be used, if source files may overwrite newer destination files and the last modified time of destFile file should be made equal to the last modified time of sourceFile.

 public boolean createNewFile(File f) throws IOException 
{
        return f.createNewFile();
}

This was originally an emulation of File.createNewFile for JDK 1.1, but it is now implemented using that method (Ant 1.6.3 onwards).

This method has historically not guaranteed that the operation was atomic. In its current implementation it is.

 public boolean createNewFile(File f,
    boolean mkdirs) throws IOException 
{
        File parent = f.getParentFile();
        if (mkdirs && !(parent.exists())) {
            parent.mkdirs();
        }
        return f.createNewFile();
}

Create a new file, optionally creating parent directories.

 public File createTempFile(String prefix,
    String suffix,
    File parentDir) 
{
        return createTempFile(prefix, suffix, parentDir, false);
}

Create a File object for a temporary file in a given directory. Without actually creating the file.

The file denoted by the returned abstract pathname did not exist before this method was invoked, any subsequent invocation of this method will yield a different file name.

The filename is prefixNNNNNsuffix where NNNN is a random number.

 public File createTempFile(String prefix,
    String suffix,
    File parentDir,
    boolean deleteOnExit) 
{
        return createTempFile(prefix, suffix, parentDir, deleteOnExit, false);
}

Create a File object for a temporary file in a given directory. Without actually creating the file.

The file denoted by the returned abstract pathname did not exist before this method was invoked, any subsequent invocation of this method will yield a different file name.

The filename is prefixNNNNNsuffix where NNNN is a random number.

 public File createTempFile(String prefix,
    String suffix,
    File parentDir,
    boolean deleteOnExit,
    boolean createFile) 
{
        File result = null;
        String parent = (parentDir == null)
                ? System.getProperty("java.io.tmpdir")
                : parentDir.getPath();
        if (createFile) {
            try {
                result = File.createTempFile(prefix, suffix, new File(parent));
            } catch (IOException e) {
                throw new BuildException("Could not create tempfile in "
                        + parent, e);
            }
        } else {
            DecimalFormat fmt = new DecimalFormat("#####");
            synchronized (rand) {
                do {
                    result = new File(parent, prefix
                            + fmt.format(Math.abs(rand.nextInt())) + suffix);
                } while (result.exists());
            }
        }
        if (deleteOnExit) {
            result.deleteOnExit();
        }
        return result;
}

Create a temporary file in a given directory.

The file denoted by the returned abstract pathname did not exist before this method was invoked, any subsequent invocation of this method will yield a different file name.

 public static  void delete(File file) 
{
        if (file != null) {
            file.delete();
        }
}

Delete the file with File#delete() if the argument is not null. Do nothing on a null argument.

 public String[] dissect(String path) 
{
        char sep = File.separatorChar;
        path = path.replace('/", sep).replace('\\", sep);
        // make sure we are dealing with an absolute path
        if (!isAbsolutePath(path)) {
            throw new BuildException(path + " is not an absolute path");
        }
        String root = null;
        int colon = path.indexOf(':");
        if (colon  > 0 && (ON_DOS || ON_NETWARE)) {
            int next = colon + 1;
            root = path.substring(0, next);
            char[] ca = path.toCharArray();
            root += sep;
            //remove the initial separator; the root has it.
            next = (ca[next] == sep) ? next + 1 : next;
            StringBuffer sbPath = new StringBuffer();
            // Eliminate consecutive slashes after the drive spec:
            for (int i = next; i <  ca.length; i++) {
                if (ca[i] != sep || ca[i - 1] != sep) {
                    sbPath.append(ca[i]);
                }
            }
            path = sbPath.toString();
        } else if (path.length()  > 1 && path.charAt(1) == sep) {
            // UNC drive
            int nextsep = path.indexOf(sep, 2);
            nextsep = path.indexOf(sep, nextsep + 1);
            root = (nextsep  > 2) ? path.substring(0, nextsep + 1) : path;
            path = path.substring(root.length());
        } else {
            root = File.separator;
            path = path.substring(1);
        }
        return new String[] {root, path};
}

Dissect the specified absolute path.

 public boolean fileNameEquals(File f1,
    File f2) 
{
        return normalize(f1.getAbsolutePath()).getAbsolutePath().equals(
                normalize(f2.getAbsolutePath()).getAbsolutePath());
}

Compares two filenames.

Unlike java.io.File#equals this method will try to compare the absolute paths and "normalize" the filenames before comparing them.

 public String fromURI(String uri) 
{
        synchronized (cacheFromUriLock) {
            if (uri.equals(cacheFromUriRequest)) {
                return cacheFromUriResponse;
            }
            String path = Locator.fromURI(uri);
            String ret = isAbsolutePath(path) ? normalize(path).getAbsolutePath() : path;
            cacheFromUriRequest = uri;
            cacheFromUriResponse = ret;
            return ret;
        }
}

Constructs a file path from a file: URI.

Will be an absolute path if the given URI is absolute.

Swallows '%' that are not followed by two characters, doesn't deal with non-ASCII characters.

 public String getDefaultEncoding() 
{
        InputStreamReader is = new InputStreamReader(
            new InputStream() {
                public int read() {
                    return -1;
                }
            });
        try {
            return is.getEncoding();
        } finally {
            close(is);
        }
}

Get the default encoding. This is done by opening an InputStreamReader on a dummy InputStream and getting the encoding. Could use System.getProperty("file.encoding"), but cannot see where this is documented.

 public long getFileTimestampGranularity() 
{
        if (ON_WIN9X) {
            return FAT_FILE_TIMESTAMP_GRANULARITY;
        }
        if (ON_WINDOWS) {
            return NTFS_FILE_TIMESTAMP_GRANULARITY;
        }
        if (ON_DOS) {
            return FAT_FILE_TIMESTAMP_GRANULARITY;
        }
        return UNIX_FILE_TIMESTAMP_GRANULARITY;
}

Get the granularity of file timestamps. The choice is made based on OS, which is incorrect--it should really be by filesystem. We do not have an easy way to probe for file systems, however, so this heuristic gives us a decent default.

 public URL getFileURL(File file) throws MalformedURLException 
{
        return new URL(toURI(file.getAbsolutePath()));
}

Get the URL for a file taking into account # characters.

 public static FileUtils getFileUtils() 
{
        return PRIMARY_INSTANCE;
}

Method to retrieve The FileUtils, which is shared by all users of this method.

 public File getParentFile(File f) 
{
        return (f == null) ? null : f.getParentFile();
}

This was originally an emulation of File#getParentFile for JDK 1.1, but it is now implemented using that method (Ant 1.6.3 onwards).

 public static String getPath(List pathStack) 
{
        // can safely use '/' because Windows understands '/' as separator
        return getPath(pathStack, '/");
}

Gets path from a List of Strings.

 public static String getPath(List pathStack,
    char separatorChar) 
{
        final StringBuffer buffer = new StringBuffer();
        final Iterator iter = pathStack.iterator();
        if (iter.hasNext()) {
            buffer.append(iter.next());
        }
        while (iter.hasNext()) {
            buffer.append(separatorChar);
            buffer.append(iter.next());
        }
        return buffer.toString();
}

Gets path from a List of Strings.

 public static String[] getPathStack(String path) 
{
        String normalizedPath = path.replace(File.separatorChar, '/");
        // since Java 1.4
        //return normalizedPath.split("/");
        // workaround for Java 1.2-1.3
        Object[] tokens = StringUtils.split(normalizedPath, '/").toArray();
        String[] rv = new String[tokens.length];
        System.arraycopy(tokens, 0, rv, 0, tokens.length);
        return rv;
}

Gets all names of the path as an array of Strings.

 public static String getRelativePath(File fromFile,
    File toFile) throws Exception 
{
        String fromPath = fromFile.getCanonicalPath();
        String toPath = toFile.getCanonicalPath();
        // build the path stack info to compare
        String[] fromPathStack = getPathStack(fromPath);
        String[] toPathStack = getPathStack(toPath);
        if (0 <  toPathStack.length && 0 <  fromPathStack.length) {
            if (!fromPathStack[0].equals(toPathStack[0])) {
                // not the same device (would be "" on Linux/Unix)
                return getPath(Arrays.asList(toPathStack));
            }
        } else {
            // no comparison possible
            return getPath(Arrays.asList(toPathStack));
        }
        int minLength = Math.min(fromPathStack.length, toPathStack.length);
        int same = 1; // Used outside the for loop
        // get index of parts which are equal
        for (;
             same <  minLength && fromPathStack[same].equals(toPathStack[same]);
             same++) {
            // Do nothing
        }
        List relativePathStack = new ArrayList();
        // if "from" part is longer, fill it up with ".."
        // to reach path which is equal to both paths
        for (int i = same; i <  fromPathStack.length; i++) {
            relativePathStack.add("..");
        }
        // fill it up path with parts which were not equal
        for (int i = same; i <  toPathStack.length; i++) {
            relativePathStack.add(toPathStack[i]);
        }
        return getPath(relativePathStack);
}

Calculates the relative path between two files.

Implementation note:
This function may throw an IOException if an I/O error occurs because its use of the canonical pathname may require filesystem queries.

 public boolean hasErrorInCase(File localFile) 
{
        localFile = normalize(localFile.getAbsolutePath());
        if (!localFile.exists()) {
            return false;
        }
        final String localFileName = localFile.getName();
        FilenameFilter ff = new FilenameFilter () {
            public boolean accept(File dir, String name) {
                return name.equalsIgnoreCase(localFileName) && (!name.equals(localFileName));
            }
        };
        String[] names = localFile.getParentFile().list(ff);
        return names != null && names.length == 1;
}

test whether a file or directory exists, with an error in the upper/lower case spelling of the name. Using this method is only interesting on case insensitive file systems (Windows).
It will return true only if 3 conditions are met :

• operating system is case insensitive
• file exists
• actual name from directory reading is different from the supplied argument

the purpose is to identify files or directories on case-insensitive filesystems whose case is not what is expected.
Possibly to rename them afterwards to the desired upper/lowercase combination.

 public static boolean isAbsolutePath(String filename) 
{
        int len = filename.length();
        if (len == 0) {
            return false;
        }
        char sep = File.separatorChar;
        filename = filename.replace('/", sep).replace('\\", sep);
        char c = filename.charAt(0);
        if (!(ON_DOS || ON_NETWARE)) {
            return (c == sep);
        }
        if (c == sep) {
            // CheckStyle:MagicNumber OFF
            if (!(ON_DOS && len  > 4 && filename.charAt(1) == sep)) {
                return false;
            }
            // CheckStyle:MagicNumber ON
            int nextsep = filename.indexOf(sep, 2);
            return nextsep  > 2 && nextsep + 1 <  len;
        }
        int colon = filename.indexOf(':");
        return (Character.isLetter(c) && colon == 1
                && filename.length()  > 2 && filename.charAt(2) == sep)
                || (ON_NETWARE && colon  > 0);
}

Verifies that the specified filename represents an absolute path. Differs from new java.io.File("filename").isAbsolute() in that a path beginning with a double file separator--signifying a Windows UNC--must at minimum match "\\a\b" to be considered an absolute path.

 public static boolean isContextRelativePath(String filename) 
{
        if (!(ON_DOS || ON_NETWARE) || filename.length() == 0) {
            return false;
        }
        char sep = File.separatorChar;
        filename = filename.replace('/", sep).replace('\\", sep);
        char c = filename.charAt(0);
        int len = filename.length();
        return (c == sep && (len == 1 || filename.charAt(1) != sep))
                || (Character.isLetter(c) && len  > 1
                && filename.indexOf(':") == 1
                && (len == 2 || filename.charAt(2) != sep));
}

On DOS and NetWare, the evaluation of certain file specifications is context-dependent. These are filenames beginning with a single separator (relative to current root directory) and filenames with a drive specification and no intervening separator (relative to current directory of the specified root).

 public boolean isLeadingPath(File leading,
    File path) 
{
        String l = normalize(leading.getAbsolutePath()).getAbsolutePath();
        String p = normalize(path.getAbsolutePath()).getAbsolutePath();
        if (l.equals(p)) {
            return true;
        }
        // ensure that l ends with a /
        // so we never think /foo was a parent directory of /foobar
        if (!l.endsWith(File.separator)) {
            l += File.separator;
        }
        return p.startsWith(l);
}

Learn whether one path "leads" another.

 public boolean isSymbolicLink(File parent,
    String name) throws IOException 
{
        if (parent == null) {
            File f = new File(name);
            parent = f.getParentFile();
            name = f.getName();
        }
        File toTest = new File(parent.getCanonicalPath(), name);
        return !toTest.getAbsolutePath().equals(toTest.getCanonicalPath());
}

Checks whether a given file is a symbolic link.

It doesn't really test for symbolic links but whether the canonical and absolute paths of the file are identical--this may lead to false positives on some platforms.

 public boolean isUpToDate(File source,
    File dest) 
{
        return isUpToDate(source, dest, getFileTimestampGranularity());
}

Returns true if the source is older than the dest.

 public boolean isUpToDate(long sourceTime,
    long destTime) 
{
        return isUpToDate(sourceTime, destTime, getFileTimestampGranularity());
}

Compare two timestamps for being up to date using the current granularity.

 public boolean isUpToDate(File source,
    File dest,
    long granularity) 
{
        //do a check for the destination file existing
        if (!dest.exists()) {
            //if it does not, then the file is not up to date.
            return false;
        }
        long sourceTime = source.lastModified();
        long destTime = dest.lastModified();
        return isUpToDate(sourceTime, destTime, granularity);
}

Returns true if the source is older than the dest. If the dest file does not exist, then the test returns false; it is implicitly not up do date.

 public boolean isUpToDate(long sourceTime,
    long destTime,
    long granularity) 
{
        return destTime != -1 && destTime  >= sourceTime + granularity;
}

Compare two timestamps for being up to date using the specified granularity.

 public static FileUtils newFileUtils() 
{
                                        
        return new FileUtils();
}

Factory method.

 public File normalize(String path) 
{
        Stack s = new Stack();
        String[] dissect = dissect(path);
        s.push(dissect[0]);
        StringTokenizer tok = new StringTokenizer(dissect[1], File.separator);
        while (tok.hasMoreTokens()) {
            String thisToken = tok.nextToken();
            if (".".equals(thisToken)) {
                continue;
            }
            if ("..".equals(thisToken)) {
                if (s.size() <  2) {
                    // Cannot resolve it, so skip it.
                    return new File(path);
                }
                s.pop();
            } else { // plain component
                s.push(thisToken);
            }
        }
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i <  s.size(); i++) {
            if (i  > 1) {
                // not before the filesystem root and not after it, since root
                // already contains one
                sb.append(File.separatorChar);
            }
            sb.append(s.elementAt(i));
        }
        return new File(sb.toString());
}

"Normalize" the given absolute path.

This includes:

• Uppercase the drive letter if there is one.
• Remove redundant slashes after the drive spec.
• Resolve all ./, .\, ../ and ..\ sequences.
• DOS style paths that start with a drive letter will have \ as the separator.
Unlike File#getCanonicalPath() this method specifically does not resolve symbolic links.

 public static String readFully(Reader rdr) throws IOException 
{
        return readFully(rdr, BUF_SIZE);
}

Read from reader till EOF.

 public static String readFully(Reader rdr,
    int bufferSize) throws IOException 
{
        if (bufferSize < = 0) {
            throw new IllegalArgumentException("Buffer size must be greater "
                                               + "than 0");
        }
        final char[] buffer = new char[bufferSize];
        int bufferLength = 0;
        StringBuffer textBuffer = null;
        while (bufferLength != -1) {
            bufferLength = rdr.read(buffer);
            if (bufferLength  > 0) {
                textBuffer = (textBuffer == null) ? new StringBuffer() : textBuffer;
                textBuffer.append(new String(buffer, 0, bufferLength));
            }
        }
        return (textBuffer == null) ? null : textBuffer.toString();
}

Read from reader till EOF.

 public String removeLeadingPath(File leading,
    File path) 
{
        String l = normalize(leading.getAbsolutePath()).getAbsolutePath();
        String p = normalize(path.getAbsolutePath()).getAbsolutePath();
        if (l.equals(p)) {
            return "";
        }
        // ensure that l ends with a /
        // so we never think /foo was a parent directory of /foobar
        if (!l.endsWith(File.separator)) {
            l += File.separator;
        }
        return (p.startsWith(l)) ? p.substring(l.length()) : p;
}

Removes a leading path from a second path.

 public  void rename(File from,
    File to) throws IOException 
{
        from = normalize(from.getAbsolutePath()).getCanonicalFile();
        to = normalize(to.getAbsolutePath());
        if (!from.exists()) {
            System.err.println("Cannot rename nonexistent file " + from);
            return;
        }
        if (from.equals(to)) {
            System.err.println("Rename of " + from + " to " + to + " is a no-op.");
            return;
        }
        if (to.exists() && !(from.equals(to.getCanonicalFile()) || to.delete())) {
            throw new IOException("Failed to delete " + to + " while trying to rename " + from);
        }
        File parent = to.getParentFile();
        if (parent != null && !parent.exists() && !parent.mkdirs()) {
            throw new IOException("Failed to create directory " + parent
                                  + " while trying to rename " + from);
        }
        if (!from.renameTo(to)) {
            copyFile(from, to);
            if (!from.delete()) {
                throw new IOException("Failed to delete " + from + " while trying to rename it.");
            }
        }
}

Renames a file, even if that involves crossing file system boundaries.

This will remove to (if it exists), ensure that to's parent directory exists and move from, which involves deleting from as well.

 public File resolveFile(File file,
    String filename) 
{
        if (!isAbsolutePath(filename)) {
            char sep = File.separatorChar;
            filename = filename.replace('/", sep).replace('\\", sep);
            if (isContextRelativePath(filename)) {
                file = null;
                // on cygwin, our current directory can be a UNC;
                // assume user.dir is absolute or all hell breaks loose...
                String udir = System.getProperty("user.dir");
                if (filename.charAt(0) == sep && udir.charAt(0) == sep) {
                    filename = dissect(udir)[0] + filename.substring(1);
                }
            }
            filename = new File(file, filename).getAbsolutePath();
        }
        return normalize(filename);
}

Interpret the filename as a file relative to the given file unless the filename already represents an absolute filename. Differs from new File(file, filename) in that the resulting File's path will always be a normalized, absolute pathname. Also, if it is determined that filename is context-relative, file will be discarded and the reference will be resolved using available context/state information about the filesystem.

 public static String safeReadFully(Reader reader) throws IOException 
{
        String ret = readFully(reader);
        return ret == null ? "" : ret;
}

Safe read fully - do not return a null for an empty reader.

 public  void setFileLastModified(File file,
    long time) 
{
        ResourceUtils.setLastModified(new FileResource(file), time);
}

Calls File.setLastModified(long time). Originally written to to dynamically bind to that call on Java1.2+.

 public String toURI(String path) 
{
        // #8031: first try Java 1.4.
        Class uriClazz = null;
        try {
            uriClazz = Class.forName("java.net.URI");
        } catch (ClassNotFoundException e) {
            // OK, Java 1.3.
        }
        if (uriClazz != null) {
            try {
                File f = new File(path).getAbsoluteFile();
                java.lang.reflect.Method toURIMethod = File.class.getMethod("toURI", new Class[0]);
                Object uriObj = toURIMethod.invoke(f, new Object[] {});
                java.lang.reflect.Method toASCIIStringMethod
                        = uriClazz.getMethod("toASCIIString", new Class[0]);
                return (String) toASCIIStringMethod.invoke(uriObj, new Object[] {});
            } catch (Exception e) {
                // Reflection problems? Should not happen, debug.
                e.printStackTrace();
            }
        }
        boolean isDir = new File(path).isDirectory();
        StringBuffer sb = new StringBuffer("file:");
        path = resolveFile(null, path).getPath();
        sb.append("//");
        // add an extra slash for filesystems with drive-specifiers
        if (!path.startsWith(File.separator)) {
            sb.append("/");
        }
        path = path.replace('\\", '/");
        try {
            sb.append(Locator.encodeURI(path));
        } catch (UnsupportedEncodingException exc) {
            throw new BuildException(exc);
        }
        if (isDir && !path.endsWith("/")) {
            sb.append('/");
        }
        return sb.toString();
}

Constructs a file: URI that represents the external form of the given pathname.

Will be an absolute URI if the given path is absolute.

This code encodes non ASCII characters too.

The coding of the output is the same as what File.toURI().toASCIIString() produces

See dt-sysid which makes some mention of how characters not supported by URI Reference syntax should be escaped.

 public String toVMSPath(File f) 
{
        // format: "DEVICE:[DIR.SUBDIR]FILE"
        String osPath;
        String path = normalize(f.getAbsolutePath()).getPath();
        String name = f.getName();
        boolean isAbsolute = path.charAt(0) == File.separatorChar;
        // treat directories specified using .DIR syntax as files
        // CheckStyle:MagicNumber OFF
        boolean isDirectory = f.isDirectory()
                && !name.regionMatches(true, name.length() - 4, ".DIR", 0, 4);
        // CheckStyle:MagicNumber ON
        String device = null;
        StringBuffer directory = null;
        String file = null;
        int index = 0;
        if (isAbsolute) {
            index = path.indexOf(File.separatorChar, 1);
            if (index == -1) {
                return path.substring(1) + ":[000000]";
            }
            device = path.substring(1, index++);
        }
        if (isDirectory) {
            directory = new StringBuffer(path.substring(index).replace(File.separatorChar, '."));
        } else {
            int dirEnd = path.lastIndexOf(File.separatorChar, path.length());
            if (dirEnd == -1 || dirEnd <  index) {
                file = path.substring(index);
            } else {
                directory = new StringBuffer(path.substring(index, dirEnd).
                                             replace(File.separatorChar, '."));
                index = dirEnd + 1;
                if (path.length()  > index) {
                    file = path.substring(index);
                }
            }
        }
        if (!isAbsolute && directory != null) {
            directory.insert(0, '.");
        }
        osPath = ((device != null) ? device + ":" : "")
                + ((directory != null) ? "[" + directory + "]" : "")
                + ((file != null) ? file : "");
        return osPath;
}

Returns a VMS String representation of a File object. This is useful since the JVM by default internally converts VMS paths to Unix style. The returned String is always an absolute path.

 public static String translatePath(String toProcess) 
{
        if (toProcess == null || toProcess.length() == 0) {
            return "";
        }
        StringBuffer path = new StringBuffer(toProcess.length() + EXPAND_SPACE);
        PathTokenizer tokenizer = new PathTokenizer(toProcess);
        while (tokenizer.hasMoreTokens()) {
            String pathComponent = tokenizer.nextToken();
            pathComponent = pathComponent.replace('/", File.separatorChar);
            pathComponent = pathComponent.replace('\\", File.separatorChar);
            if (path.length() != 0) {
                path.append(File.pathSeparatorChar);
            }
            path.append(pathComponent);
        }
        return path.toString();
}

Translate a path into its native (platform specific) format.

This method uses PathTokenizer to separate the input path into its components. This handles DOS style paths in a relatively sensible way. The file separators are then converted to their platform specific versions.