com.izforge.izpack.util.file.FileUtils Maven / Gradle / Ivy
/*
* Copyright 2001-2005 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package com.izforge.izpack.util.file;
import com.izforge.izpack.util.OsVersion;
import org.apache.commons.io.FilenameUtils;
import java.io.File;
import java.io.IOException;
/**
* This class also encapsulates methods which allow Files to be
* referred to using abstract path names which are translated to native
* system file paths at runtime as well as copying files or setting
* their last modification time.
*/
public class FileUtils
{
/**
* The granularity of timestamps under FAT.
*/
public static final long FAT_FILE_TIMESTAMP_GRANULARITY = 2000;
/**
* The granularity of timestamps under Unix.
*/
public static final long UNIX_FILE_TIMESTAMP_GRANULARITY = 1000;
/**
* Convenience method to copy a file from a source to a destination.
* No filtering is performed.
*
* @param sourceFile Name of file to copy from.
* Must not be null.
* @param destFile Name of file to copy to.
* Must not be null.
* @throws IOException if the copying fails.
*/
public static void copyFile(String sourceFile, String destFile,
boolean overwrite, boolean preserveLastModified)
throws IOException
{
copyFile(new File(sourceFile), new File(destFile), overwrite, preserveLastModified);
}
/**
* 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.
*
* @param sourceFile the file to copy from.
* Must not be null.
* @param destFile the file to copy to.
* Must not be null.
* @param overwrite Whether or not the destination file should be
* overwritten if it already exists.
* @param preserveLastModified Whether or not the last modified time of
* the resulting file should be set to that
* of the source file.
* @throws IOException if the copying fails.
*/
public static void copyFile(File sourceFile, File destFile, boolean overwrite, boolean preserveLastModified)
throws IOException
{
if (overwrite || !destFile.exists()
|| destFile.lastModified() < sourceFile.lastModified())
{
org.apache.commons.io.FileUtils.copyFile(sourceFile, destFile, preserveLastModified);
}
}
/**
* Interpret the filename as a file relative to the given file
* unless the filename already represents an absolute filename.
*
* @param file the "reference" file for relative paths. This
* instance must be an absolute file and must not contain
* "./" or "../" sequences (same for \ instead
* of /). If it is null, this call is equivalent to
* new java.io.File(filename).
* @param filename a file name.
* @return an absolute file that doesn't contain "./" or
* "../" sequences and uses the correct separator for
* the current platform.
*/
public static File resolveFile(File file, String filename) throws Exception
{
return new File(FilenameUtils.concat(file==null?null:file.getPath(), filename));
}
/**
* This was originally an emulation of {@link File#getParentFile} for JDK 1.1,
* but it is now implemented using that method (Ant 1.6.3 onwards).
*
* @param f the file whose parent is required.
* @return the given file's parent, or null if the file does not have a
* parent.
*/
public static File getParentFile(File f)
{
return (f == null) ? null : f.getParentFile();
}
/**
* 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.
*
* @param parent the parent directory of the file to test
* @param name the name of the file to test.
* @return true if the file is a symbolic link.
* @throws IOException on error.
*/
public static 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 org.apache.commons.io.FileUtils.isSymlink(toTest);
}
/**
* Removes a leading path from a second path.
*
* @param leading The leading path, must not be null, must be absolute.
* @param path The path to remove from, must not be null, must be absolute.
* @return path's normalized absolute if it doesn't start with
* leading; path's path with leading's path removed otherwise.
*/
public static String removeLeadingPath(File leading, File path) throws Exception
{
String l = FilenameUtils.normalize(leading.getAbsolutePath());
String p = FilenameUtils.normalize(path.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;
}
/**
* 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.
*
* @return the difference, in milliseconds, which two file timestamps must have
* in order for the two files to be given a creation order.
*/
public static long getFileTimestampGranularity()
{
return OsVersion.IS_WINDOWS
? FAT_FILE_TIMESTAMP_GRANULARITY : UNIX_FILE_TIMESTAMP_GRANULARITY;
}
/**
* Create a temporary directory.
*
* @param prefix the prefix string to be used in generating the directory's
* name; must be at least three characters long
* @param directory the directory in which the file is to be created, or
* null if the default temporary-file directory is to be used
*
* @return a new temporary directory
*
* @throws IOException if the creation of the directory fails
*/
public static File createTempDirectory(String prefix, File directory) throws IOException
{
// create a unique temporary file name
File tempFile = File.createTempFile(prefix, "", directory);
tempFile.delete();
// append a "d" suffix to the temporary directory name as the temp file may not be
// immediately deleted by the JVM
File tempDirectory = new File(tempFile.getPath() + ".tmp");
if (!tempDirectory.mkdirs())
{
throw new IOException("Failed to create temporary directory: " + tempDirectory);
}
return tempDirectory;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy