com.itextpdf.commons.utils.FileUtil Maven / Gradle / Ivy
/*
This file is part of the iText (R) project.
Copyright (c) 1998-2023 Apryse Group NV
Authors: Apryse Software.
This program is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at https://itextpdf.com/sales. For AGPL licensing, see below.
AGPL licensing:
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see list = new ArrayList<>();
for (File file : files) {
if (file.isDirectory() && recursive) {
listAllFiles(file.getAbsolutePath(), list);
} else {
list.add(file.getAbsolutePath());
}
}
return list.toArray(new String[0]);
}
}
}
return null;
}
/**
* Lists all the files located at the provided directory, which are accepted by the provided filter.
*
* @param outPath path to the directory
* @param fileFilter filter to accept files to be listed
*
* @return all the files located at the provided directory, which are accepted by the provided filter
*/
public static File[] listFilesInDirectoryByFilter(String outPath, FileFilter fileFilter) {
File[] result = null;
if (outPath != null && !outPath.isEmpty()) {
result = new File(outPath).listFiles(fileFilter);
}
if (result != null) {
// Guarantee invariant order in all environments
Arrays.sort(result, new CaseSensitiveFileComparator());
}
return result;
}
private static void listAllFiles(String dir, List list) {
File[] files = new File(dir).listFiles();
if (files != null) {
// Guarantee invariant order in all environments
Arrays.sort(files, new CaseSensitiveFileComparator());
for (File file : files) {
if (file.isDirectory()) {
listAllFiles(file.getAbsolutePath(), list);
} else {
list.add(file.getAbsolutePath());
}
}
}
}
public static PrintWriter createPrintWriter(OutputStream output,
String encoding) throws UnsupportedEncodingException {
return new PrintWriter(new OutputStreamWriter(output, encoding));
}
public static java.io.OutputStream getBufferedOutputStream(String filename) throws FileNotFoundException {
return new BufferedOutputStream(new FileOutputStream(filename));
}
public static java.io.OutputStream wrapWithBufferedOutputStream(OutputStream outputStream) {
if (outputStream instanceof ByteArrayOutputStream || (outputStream instanceof BufferedOutputStream)) {
return outputStream;
} else {
return new BufferedOutputStream(outputStream);
}
}
public static File constructFileByDirectoryAndName(String directory, String fileName) {
return new File(directory, fileName);
}
/**
* Creates a temporary file at the provided path.
*
* @param path path to the temporary file to be created. If it is a directory, then the temporary file
* will be created at this directory
*
* @return the created temporary file
*
* @throws IOException signals that an I/O exception has occurred
*/
public static File createTempFile(String path) throws IOException {
File tempFile = new File(path);
if (tempFile.isDirectory()) {
tempFile = File.createTempFile("pdf", null, tempFile);
}
return tempFile;
}
public static FileOutputStream getFileOutputStream(File tempFile) throws FileNotFoundException {
return new FileOutputStream(tempFile);
}
public static InputStream getInputStreamForFile(String path) throws IOException {
return Files.newInputStream(Paths.get(path));
}
public static OutputStream getFileOutputStream(String path) throws IOException {
return Files.newOutputStream(Paths.get(path));
}
public static RandomAccessFile getRandomAccessFile(File tempFile) throws FileNotFoundException {
return new RandomAccessFile(tempFile, "rw");
}
/**
* Creates a directory at the provided path.
*
* @param outPath path to the directory to be created
*/
public static void createDirectories(String outPath) {
new File(outPath).mkdirs();
}
public static String getParentDirectoryUri(File file) throws MalformedURLException {
return file != null ? Paths.get(file.getParent()).toUri().toURL().toExternalForm() : "";
}
/**
* Deletes a file and returns whether the operation succeeded.
* Note that only *files* are supported, not directories.
*
* @param file file to be deleted
* @return true if file was deleted successfully, false otherwise
*/
public static boolean deleteFile(File file) {
return file.delete();
}
/**
* Returns an URL of the parent directory for the resource.
*
* @param url of resource
*
* @return parent directory path| the same path if a catalog`s url is passed;
* @throws URISyntaxException if this URL is not formatted strictly according
* to RFC2396 and cannot be converted to a URI.
*/
public static String parentDirectory(URL url) throws URISyntaxException {
return url.toURI().resolve(".").toString();
}
/**
* Creates a temporary file.
*
*
* Note, that this method creates temporary file with provided file's prefix and postfix
* using {@link File#createTempFile(String, String)}.
*
* @param tempFilePrefix the prefix of the copied file's name
* @param tempFilePostfix the postfix of the copied file's name
*
* @return the path to the copied file
*
* @throws IOException signals that an I/O exception has occurred.
*/
public static File createTempFile(String tempFilePrefix, String tempFilePostfix) throws IOException {
return File.createTempFile(tempFilePrefix, tempFilePostfix);
}
/**
* Creates a temporary copy of a file.
*
*
* Note, that this method creates temporary file with provided file's prefix and postfix
* using {@link Files#createTempFile(String, String, FileAttribute[])}.
*
* @param file the path to the file to be copied
* @param tempFilePrefix the prefix of the copied file's name
* @param tempFilePostfix the postfix of the copied file's name
*
* @return the path to the copied file
*
* @throws IOException signals that an I/O exception has occurred.
*/
public static String createTempCopy(String file, String tempFilePrefix, String tempFilePostfix)
throws IOException {
Path replacementFilePath = null;
try {
replacementFilePath = Files.createTempFile(tempFilePrefix, tempFilePostfix);
Path pathToPassedFile = Paths.get(file);
Files.copy(pathToPassedFile, replacementFilePath, StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
if (null != replacementFilePath) {
FileUtil.removeFiles(new String[] {replacementFilePath.toString()});
}
throw e;
}
return replacementFilePath.toString();
}
/**
* Creates a copy of a file.
*
* @param inputFile the path to the file to be copied
* @param outputFile the path, to which the passed file should be copied
*
* @throws IOException signals that an I/O exception has occurred.
*/
public static void copy(String inputFile, String outputFile)
throws IOException {
Files.copy(Paths.get(inputFile), Paths.get(outputFile), StandardCopyOption.REPLACE_EXISTING);
}
/**
* Creates a temporary directory.
*
*
* Note, that this method creates temporary directory with provided directory prefix
* using {@link Files#createTempDirectory(String, FileAttribute[])}.
*
* @param tempFilePrefix the prefix of the temporary directory's name
*
* @return the path to the temporary directory
*
* @throws IOException signals that an I/O exception has occurred.
*/
public static String createTempDirectory(String tempFilePrefix)
throws IOException {
return Files.createTempDirectory(tempFilePrefix).toString();
}
/**
* Removes all of the passed files.
*
* @param paths paths to files, which should be removed
*
* @return {@code true} if all the files have been successfully removed, {@code false} otherwise
*/
public static boolean removeFiles(String[] paths) {
boolean allFilesAreRemoved = true;
for (String path : paths) {
try {
if (null != path) {
Files.delete(Paths.get(path));
}
} catch (Exception e) {
allFilesAreRemoved = false;
}
}
return allFilesAreRemoved;
}
private static class CaseSensitiveFileComparator implements Comparator {
@Override
public int compare(File f1, File f2) {
return f1.getPath().compareTo(f2.getPath());
}
}
}