deleteFailures = Collections.synchronizedList(new ArrayList<>());
/**
* Whether to terminate the thread when the tracking is complete.
*/
volatile boolean exitWhenFinished;
/**
* The thread that will clean up registered files.
*/
Thread reaper;
/**
* Adds a tracker to the list of trackers.
*
* @param path the full path to the file to be tracked, not null
* @param marker the marker object used to track the file, not null
* @param deleteStrategy the strategy to delete the file, null means normal
*/
private synchronized void addTracker(final String path, final Object marker, final FileDeleteStrategy
deleteStrategy) {
// synchronized block protects reaper
if (exitWhenFinished) {
throw new IllegalStateException("No new trackers can be added once exitWhenFinished() is called");
}
if (reaper == null) {
reaper = new Reaper();
reaper.start();
}
trackers.add(new Tracker(path, deleteStrategy, marker, q));
}
/**
* Call this method to cause the file cleaner thread to terminate when
* there are no more objects being tracked for deletion.
*
* In a simple environment, you don't need this method as the file cleaner
* thread will simply exit when the JVM exits. In a more complex environment,
* with multiple class loaders (such as an application server), you should be
* aware that the file cleaner thread will continue running even if the class
* loader it was started from terminates. This can constitute a memory leak.
*
* For example, suppose that you have developed a web application, which
* contains the commons-io jar file in your WEB-INF/lib directory. In other
* words, the FileCleaner class is loaded through the class loader of your
* web application. If the web application is terminated, but the servlet
* container is still running, then the file cleaner thread will still exist,
* posing a memory leak.
*
* This method allows the thread to be terminated. Simply call this method
* in the resource cleanup code, such as
* {@code javax.servlet.ServletContextListener.contextDestroyed(javax.servlet.ServletContextEvent)}.
* Once called, no new objects can be tracked by the file cleaner.
*/
public synchronized void exitWhenFinished() {
// synchronized block protects reaper
exitWhenFinished = true;
if (reaper != null) {
synchronized (reaper) {
reaper.interrupt();
}
}
}
/**
* Gets a copy of the file paths that failed to delete.
*
* @return a copy of the file paths that failed to delete
* @since 2.0
*/
public List getDeleteFailures() {
return new ArrayList<>(deleteFailures);
}
/**
* Gets the number of files currently being tracked, and therefore
* awaiting deletion.
*
* @return the number of files being tracked
*/
public int getTrackCount() {
return trackers.size();
}
/**
* Tracks the specified file, using the provided marker, deleting the file
* when the marker instance is garbage collected.
* The {@link FileDeleteStrategy#NORMAL normal} deletion strategy will be used.
*
* @param file the file to be tracked, not null
* @param marker the marker object used to track the file, not null
* @throws NullPointerException if the file is null
*/
public void track(final File file, final Object marker) {
track(file, marker, null);
}
/**
* Tracks the specified file, using the provided marker, deleting the file
* when the marker instance is garbage collected.
* The specified deletion strategy is used.
*
* @param file the file to be tracked, not null
* @param marker the marker object used to track the file, not null
* @param deleteStrategy the strategy to delete the file, null means normal
* @throws NullPointerException if the file is null
*/
public void track(final File file, final Object marker, final FileDeleteStrategy deleteStrategy) {
Objects.requireNonNull(file, "file");
addTracker(file.getPath(), marker, deleteStrategy);
}
/**
* Tracks the specified file, using the provided marker, deleting the file
* when the marker instance is garbage collected.
* The {@link FileDeleteStrategy#NORMAL normal} deletion strategy will be used.
*
* @param file the file to be tracked, not null
* @param marker the marker object used to track the file, not null
* @throws NullPointerException if the file is null
* @since 2.14.0
*/
public void track(final Path file, final Object marker) {
track(file, marker, null);
}
/**
* Tracks the specified file, using the provided marker, deleting the file
* when the marker instance is garbage collected.
* The specified deletion strategy is used.
*
* @param file the file to be tracked, not null
* @param marker the marker object used to track the file, not null
* @param deleteStrategy the strategy to delete the file, null means normal
* @throws NullPointerException if the file is null
* @since 2.14.0
*/
public void track(final Path file, final Object marker, final FileDeleteStrategy deleteStrategy) {
Objects.requireNonNull(file, "file");
addTracker(file.toAbsolutePath().toString(), marker, deleteStrategy);
}
/**
* Tracks the specified file, using the provided marker, deleting the file
* when the marker instance is garbage collected.
* The {@link FileDeleteStrategy#NORMAL normal} deletion strategy will be used.
*
* @param path the full path to the file to be tracked, not null
* @param marker the marker object used to track the file, not null
* @throws NullPointerException if the path is null
*/
public void track(final String path, final Object marker) {
track(path, marker, null);
}
/**
* Tracks the specified file, using the provided marker, deleting the file
* when the marker instance is garbage collected.
* The specified deletion strategy is used.
*
* @param path the full path to the file to be tracked, not null
* @param marker the marker object used to track the file, not null
* @param deleteStrategy the strategy to delete the file, null means normal
* @throws NullPointerException if the path is null
*/
public void track(final String path, final Object marker, final FileDeleteStrategy deleteStrategy) {
Objects.requireNonNull(path, "path");
addTracker(path, marker, deleteStrategy);
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/FileDeleteStrategy.java 0100644 0000000 0000000 00000012501 14603604450 030124 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.File;
import java.io.IOException;
/**
* Strategy for deleting files.
*
* There is more than one way to delete a file.
* You may want to limit access to certain directories, to only delete
* directories if they are empty, or maybe to force deletion.
*
*
* This class captures the strategy to use and is designed for user subclassing.
*
*
* @since 1.3
*/
public class FileDeleteStrategy {
/**
* Force file deletion strategy.
*/
static class ForceFileDeleteStrategy extends FileDeleteStrategy {
/** Default Constructor */
ForceFileDeleteStrategy() {
super("Force");
}
/**
* Deletes the file object.
*
* This implementation uses {@code FileUtils.forceDelete()}
* if the file exists.
*
*
* @param fileToDelete the file to delete, not null
* @return Always returns {@code true}
* @throws NullPointerException if the file is null
* @throws IOException if an error occurs during file deletion
*/
@Override
protected boolean doDelete(final File fileToDelete) throws IOException {
FileUtils.forceDelete(fileToDelete);
return true;
}
}
/**
* The singleton instance for normal file deletion, which does not permit
* the deletion of directories that are not empty.
*/
public static final FileDeleteStrategy NORMAL = new FileDeleteStrategy("Normal");
/**
* The singleton instance for forced file deletion, which always deletes,
* even if the file represents a non-empty directory.
*/
public static final FileDeleteStrategy FORCE = new ForceFileDeleteStrategy();
/** The name of the strategy. */
private final String name;
/**
* Restricted constructor.
*
* @param name the name by which the strategy is known
*/
protected FileDeleteStrategy(final String name) {
this.name = name;
}
/**
* Deletes the file object, which may be a file or a directory.
* If the file does not exist, the method just returns.
*
* Subclass writers should override {@link #doDelete(File)}, not this method.
*
*
* @param fileToDelete the file to delete, not null
* @throws NullPointerException if the file is null
* @throws IOException if an error occurs during file deletion
*/
public void delete(final File fileToDelete) throws IOException {
if (fileToDelete.exists() && !doDelete(fileToDelete)) {
throw new IOException("Deletion failed: " + fileToDelete);
}
}
/**
* Deletes the file object, which may be a file or a directory.
* All {@link IOException}s are caught and false returned instead.
* If the file does not exist or is null, true is returned.
*
* Subclass writers should override {@link #doDelete(File)}, not this method.
*
*
* @param fileToDelete the file to delete, null returns true
* @return true if the file was deleted, or there was no such file
*/
public boolean deleteQuietly(final File fileToDelete) {
if (fileToDelete == null || !fileToDelete.exists()) {
return true;
}
try {
return doDelete(fileToDelete);
} catch (final IOException ex) {
return false;
}
}
/**
* Actually deletes the file object, which may be a file or a directory.
*
* This method is designed for subclasses to override.
* The implementation may return either false or an {@link IOException}
* when deletion fails. The {@link #delete(File)} and {@link #deleteQuietly(File)}
* methods will handle either response appropriately.
* A check has been made to ensure that the file will exist.
*
*
* This implementation uses {@link FileUtils#delete(File)}.
*
*
* @param file the file to delete, exists, not null
* @return true if the file was deleted
* @throws NullPointerException if the file is null
* @throws IOException if an error occurs during file deletion
*/
protected boolean doDelete(final File file) throws IOException {
FileUtils.delete(file);
return true;
}
/**
* Gets a string describing the delete strategy.
*
* @return a string describing the delete strategy
*/
@Override
public String toString() {
return "FileDeleteStrategy[" + name + "]";
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/FileExistsException.java 0100644 0000000 0000000 00000003135 14603604450 030340 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.File;
import java.io.IOException;
/**
* Indicates that a file already exists.
*
* @since 2.0
*/
public class FileExistsException extends IOException {
/**
* Defines the serial version UID.
*/
private static final long serialVersionUID = 1L;
/**
* Default Constructor.
*/
public FileExistsException() {
}
/**
* Constructs an instance with the specified file.
*
* @param file The file that exists
*/
public FileExistsException(final File file) {
super("File " + file + " exists");
}
/**
* Constructs an instance with the specified message.
*
* @param message The error message
*/
public FileExistsException(final String message) {
super(message);
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/FileSystem.java 0100644 0000000 0000000 00000045362 14603604450 026476 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.util.Arrays;
import java.util.Locale;
import java.util.Objects;
/**
* Abstracts an OS' file system details, currently supporting the single use case of converting a file name String to a
* legal file name with {@link #toLegalFileName(String, char)}.
*
* The starting point of any operation is {@link #getCurrent()} which gets you the enum for the file system that matches
* the OS hosting the running JVM.
*
*
* @since 2.7
*/
public enum FileSystem {
/**
* Generic file system.
*/
GENERIC(4096, false, false, Integer.MAX_VALUE, Integer.MAX_VALUE, new int[] { 0 }, new String[] {}, false, false, '/'),
/**
* Linux file system.
*/
LINUX(8192, true, true, 255, 4096, new int[] {
// KEEP THIS ARRAY SORTED!
// @formatter:off
// ASCII NUL
0,
'/'
// @formatter:on
}, new String[] {}, false, false, '/'),
/**
* MacOS file system.
*/
MAC_OSX(4096, true, true, 255, 1024, new int[] {
// KEEP THIS ARRAY SORTED!
// @formatter:off
// ASCII NUL
0,
'/',
':'
// @formatter:on
}, new String[] {}, false, false, '/'),
/**
* Windows file system.
*
* The reserved characters are defined in the
* Naming Conventions
* (microsoft.com).
*
*
* @see Naming Conventions
* (microsoft.com)
* @see
* CreateFileA function - Consoles (microsoft.com)
*/
WINDOWS(4096, false, true,
255, 32000, // KEEP THIS ARRAY SORTED!
new int[] {
// KEEP THIS ARRAY SORTED!
// @formatter:off
// ASCII NUL
0,
// 1-31 may be allowed in file streams
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 30, 31,
'"', '*', '/', ':', '<', '>', '?', '\\', '|'
// @formatter:on
}, new String[] { "AUX", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "CON", "CONIN$", "CONOUT$",
"LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9", "NUL", "PRN" }, true, true, '\\');
/**
*
* Is {@code true} if this is Linux.
*
*
* The field will return {@code false} if {@code OS_NAME} is {@code null}.
*
*/
private static final boolean IS_OS_LINUX = getOsMatchesName("Linux");
/**
*
* Is {@code true} if this is Mac.
*
*
* The field will return {@code false} if {@code OS_NAME} is {@code null}.
*
*/
private static final boolean IS_OS_MAC = getOsMatchesName("Mac");
/**
* The prefix String for all Windows OS.
*/
private static final String OS_NAME_WINDOWS_PREFIX = "Windows";
/**
*
* Is {@code true} if this is Windows.
*
*
* The field will return {@code false} if {@code OS_NAME} is {@code null}.
*
*/
private static final boolean IS_OS_WINDOWS = getOsMatchesName(OS_NAME_WINDOWS_PREFIX);
/**
* The current FileSystem.
*/
private static final FileSystem CURRENT = current();
/**
* Gets the current file system.
*
* @return the current file system
*/
private static FileSystem current() {
if (IS_OS_LINUX) {
return LINUX;
}
if (IS_OS_MAC) {
return MAC_OSX;
}
if (IS_OS_WINDOWS) {
return WINDOWS;
}
return GENERIC;
}
/**
* Gets the current file system.
*
* @return the current file system
*/
public static FileSystem getCurrent() {
return CURRENT;
}
/**
* Decides if the operating system matches.
*
* @param osNamePrefix
* the prefix for the os name
* @return true if matches, or false if not or can't determine
*/
private static boolean getOsMatchesName(final String osNamePrefix) {
return isOsNameMatch(getSystemProperty("os.name"), osNamePrefix);
}
/**
*
* Gets a System property, defaulting to {@code null} if the property cannot be read.
*
*
* If a {@link SecurityException} is caught, the return value is {@code null} and a message is written to
* {@code System.err}.
*
*
* @param property
* the system property name
* @return the system property value or {@code null} if a security problem occurs
*/
private static String getSystemProperty(final String property) {
try {
return System.getProperty(property);
} catch (final SecurityException ex) {
// we are not allowed to look at this property
System.err.println("Caught a SecurityException reading the system property '" + property
+ "'; the SystemUtils property value will default to null.");
return null;
}
}
/**
* Copied from Apache Commons Lang CharSequenceUtils.
*
* Returns the index within {@code cs} of the first occurrence of the
* specified character, starting the search at the specified index.
*
* If a character with value {@code searchChar} occurs in the
* character sequence represented by the {@code cs}
* object at an index no smaller than {@code start}, then
* the index of the first such occurrence is returned. For values
* of {@code searchChar} in the range from 0 to 0xFFFF (inclusive),
* this is the smallest value k such that:
*
*
* (this.charAt(k) == searchChar) && (k >= start)
*
* is true. For other values of {@code searchChar}, it is the
* smallest value k such that:
*
* (this.codePointAt(k) == searchChar) && (k >= start)
*
*
* is true. In either case, if no such character occurs in {@code cs}
* at or after position {@code start}, then
* {@code -1} is returned.
*
*
* There is no restriction on the value of {@code start}. If it
* is negative, it has the same effect as if it were zero: the entire
* {@link CharSequence} may be searched. If it is greater than
* the length of {@code cs}, it has the same effect as if it were
* equal to the length of {@code cs}: {@code -1} is returned.
*
* All indices are specified in {@code char} values
* (Unicode code units).
*
*
* @param cs the {@link CharSequence} to be processed, not null
* @param searchChar the char to be searched for
* @param start the start index, negative starts at the string start
* @return the index where the search char was found, -1 if not found
* @since 3.6 updated to behave more like {@link String}
*/
private static int indexOf(final CharSequence cs, final int searchChar, int start) {
if (cs instanceof String) {
return ((String) cs).indexOf(searchChar, start);
}
final int sz = cs.length();
if (start < 0) {
start = 0;
}
if (searchChar < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
for (int i = start; i < sz; i++) {
if (cs.charAt(i) == searchChar) {
return i;
}
}
return -1;
}
//supplementary characters (LANG1300)
if (searchChar <= Character.MAX_CODE_POINT) {
final char[] chars = Character.toChars(searchChar);
for (int i = start; i < sz - 1; i++) {
final char high = cs.charAt(i);
final char low = cs.charAt(i + 1);
if (high == chars[0] && low == chars[1]) {
return i;
}
}
}
return -1;
}
/**
* Decides if the operating system matches.
*
* This method is package private instead of private to support unit test invocation.
*
*
* @param osName
* the actual OS name
* @param osNamePrefix
* the prefix for the expected OS name
* @return true if matches, or false if not or can't determine
*/
private static boolean isOsNameMatch(final String osName, final String osNamePrefix) {
if (osName == null) {
return false;
}
return osName.toUpperCase(Locale.ROOT).startsWith(osNamePrefix.toUpperCase(Locale.ROOT));
}
/**
* Null-safe replace.
*
* @param path the path to be changed, null ignored.
* @param oldChar the old character.
* @param newChar the new character.
* @return the new path.
*/
private static String replace(final String path, final char oldChar, final char newChar) {
return path == null ? null : path.replace(oldChar, newChar);
}
private final int blockSize;
private final boolean casePreserving;
private final boolean caseSensitive;
private final int[] illegalFileNameChars;
private final int maxFileNameLength;
private final int maxPathLength;
private final String[] reservedFileNames;
private final boolean reservedFileNamesExtensions;
private final boolean supportsDriveLetter;
private final char nameSeparator;
private final char nameSeparatorOther;
/**
* Constructs a new instance.
*
* @param blockSize file allocation block size in bytes.
* @param caseSensitive Whether this file system is case-sensitive.
* @param casePreserving Whether this file system is case-preserving.
* @param maxFileLength The maximum length for file names. The file name does not include folders.
* @param maxPathLength The maximum length of the path to a file. This can include folders.
* @param illegalFileNameChars Illegal characters for this file system.
* @param reservedFileNames The reserved file names.
* @param reservedFileNamesExtensions TODO
* @param supportsDriveLetter Whether this file system support driver letters.
* @param nameSeparator The name separator, '\\' on Windows, '/' on Linux.
*/
FileSystem(final int blockSize, final boolean caseSensitive, final boolean casePreserving,
final int maxFileLength, final int maxPathLength, final int[] illegalFileNameChars,
final String[] reservedFileNames, final boolean reservedFileNamesExtensions, final boolean supportsDriveLetter, final char nameSeparator) {
this.blockSize = blockSize;
this.maxFileNameLength = maxFileLength;
this.maxPathLength = maxPathLength;
this.illegalFileNameChars = Objects.requireNonNull(illegalFileNameChars, "illegalFileNameChars");
this.reservedFileNames = Objects.requireNonNull(reservedFileNames, "reservedFileNames");
this.reservedFileNamesExtensions = reservedFileNamesExtensions;
this.caseSensitive = caseSensitive;
this.casePreserving = casePreserving;
this.supportsDriveLetter = supportsDriveLetter;
this.nameSeparator = nameSeparator;
this.nameSeparatorOther = FilenameUtils.flipSeparator(nameSeparator);
}
/**
* Gets the file allocation block size in bytes.
* @return the file allocation block size in bytes.
*
* @since 2.12.0
*/
public int getBlockSize() {
return blockSize;
}
/**
* Gets a cloned copy of the illegal characters for this file system.
*
* @return the illegal characters for this file system.
*/
public char[] getIllegalFileNameChars() {
final char[] chars = new char[illegalFileNameChars.length];
for (int i = 0; i < illegalFileNameChars.length; i++) {
chars[i] = (char) illegalFileNameChars[i];
}
return chars;
}
/**
* Gets a cloned copy of the illegal code points for this file system.
*
* @return the illegal code points for this file system.
* @since 2.12.0
*/
public int[] getIllegalFileNameCodePoints() {
return this.illegalFileNameChars.clone();
}
/**
* Gets the maximum length for file names. The file name does not include folders.
*
* @return the maximum length for file names.
*/
public int getMaxFileNameLength() {
return maxFileNameLength;
}
/**
* Gets the maximum length of the path to a file. This can include folders.
*
* @return the maximum length of the path to a file.
*/
public int getMaxPathLength() {
return maxPathLength;
}
/**
* Gets the name separator, '\\' on Windows, '/' on Linux.
*
* @return '\\' on Windows, '/' on Linux.
*
* @since 2.12.0
*/
public char getNameSeparator() {
return nameSeparator;
}
/**
* Gets a cloned copy of the reserved file names.
*
* @return the reserved file names.
*/
public String[] getReservedFileNames() {
return reservedFileNames.clone();
}
/**
* Tests whether this file system preserves case.
*
* @return Whether this file system preserves case.
*/
public boolean isCasePreserving() {
return casePreserving;
}
/**
* Tests whether this file system is case-sensitive.
*
* @return Whether this file system is case-sensitive.
*/
public boolean isCaseSensitive() {
return caseSensitive;
}
/**
* Tests if the given character is illegal in a file name, {@code false} otherwise.
*
* @param c
* the character to test
* @return {@code true} if the given character is illegal in a file name, {@code false} otherwise.
*/
private boolean isIllegalFileNameChar(final int c) {
return Arrays.binarySearch(illegalFileNameChars, c) >= 0;
}
/**
* Tests if a candidate file name (without a path) such as {@code "filename.ext"} or {@code "filename"} is a
* potentially legal file name. If the file name length exceeds {@link #getMaxFileNameLength()}, or if it contains
* an illegal character then the check fails.
*
* @param candidate
* a candidate file name (without a path) like {@code "filename.ext"} or {@code "filename"}
* @return {@code true} if the candidate name is legal
*/
public boolean isLegalFileName(final CharSequence candidate) {
if (candidate == null || candidate.length() == 0 || candidate.length() > maxFileNameLength) {
return false;
}
if (isReservedFileName(candidate)) {
return false;
}
return candidate.chars().noneMatch(this::isIllegalFileNameChar);
}
/**
* Tests whether the given string is a reserved file name.
*
* @param candidate
* the string to test
* @return {@code true} if the given string is a reserved file name.
*/
public boolean isReservedFileName(final CharSequence candidate) {
final CharSequence test = reservedFileNamesExtensions ? trimExtension(candidate) : candidate;
return Arrays.binarySearch(reservedFileNames, test) >= 0;
}
/**
* Converts all separators to the Windows separator of backslash.
*
* @param path the path to be changed, null ignored
* @return the updated path
* @since 2.12.0
*/
public String normalizeSeparators(final String path) {
return replace(path, nameSeparatorOther, nameSeparator);
}
/**
* Tests whether this file system support driver letters.
*
* Windows supports driver letters as do other operating systems. Whether these other OS's still support Java like
* OS/2, is a different matter.
*
*
* @return whether this file system support driver letters.
* @since 2.9.0
* @see Operating systems that use drive letter
* assignment
*/
public boolean supportsDriveLetter() {
return supportsDriveLetter;
}
/**
* Converts a candidate file name (without a path) like {@code "filename.ext"} or {@code "filename"} to a legal file
* name. Illegal characters in the candidate name are replaced by the {@code replacement} character. If the file
* name length exceeds {@link #getMaxFileNameLength()}, then the name is truncated to
* {@link #getMaxFileNameLength()}.
*
* @param candidate
* a candidate file name (without a path) like {@code "filename.ext"} or {@code "filename"}
* @param replacement
* Illegal characters in the candidate name are replaced by this character
* @return a String without illegal characters
*/
public String toLegalFileName(final String candidate, final char replacement) {
if (isIllegalFileNameChar(replacement)) {
// %s does not work properly with NUL
throw new IllegalArgumentException(String.format("The replacement character '%s' cannot be one of the %s illegal characters: %s",
replacement == '\0' ? "\\0" : replacement, name(), Arrays.toString(illegalFileNameChars)));
}
final String truncated = candidate.length() > maxFileNameLength ? candidate.substring(0, maxFileNameLength) : candidate;
final int[] array = truncated.chars().map(i -> isIllegalFileNameChar(i) ? replacement : i).toArray();
return new String(array, 0, array.length);
}
CharSequence trimExtension(final CharSequence cs) {
final int index = indexOf(cs, '.', 0);
return index < 0 ? cs : cs.subSequence(0, index);
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/FileSystemUtils.java 0100644 0000000 0000000 00000015713 14603604450 027514 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Objects;
/**
* General File System utilities.
*
* This class provides static utility methods for general file system functions not provided before Java 6's {@link java.io.File File} class.
*
*
* The current functions provided are:
*
*
* - Get the free space on a drive
*
*
* @since 1.1
* @deprecated As of 2.6 deprecated without replacement. Use equivalent methods in {@link java.nio.file.FileStore} instead,
* {@code Files.getFileStore(Paths.get("/home")).getUsableSpace()} or iterate over {@code FileSystems.getDefault().getFileStores()}
*/
@Deprecated
public class FileSystemUtils {
/**
* Gets the number of kibibytes (1024 bytes) available to this Java virtual machine on the given file store.
*
* Note that some OS's are NOT currently supported, including OS/390, OpenVMS.
*
*
*
* FileSystemUtils.freeSpace("C:"); // Windows
* FileSystemUtils.freeSpace("/volume"); // *nix
*
*
* @param path the path to get free space for, not null, not empty on UNIX
* @return the amount of free drive space on the drive or volume
* @throws IOException if an I/O error occurs.
* @throws IllegalArgumentException if the path is invalid.
* @since 1.1, enhanced OS support in 1.2 and 1.3
* @deprecated Use freeSpaceKb(String) Deprecated from 1.3, may be removed in 2.0
*/
@Deprecated
public static long freeSpace(final String path) throws IOException {
return getFreeSpace(path);
}
/**
* Gets the number of kibibytes (1024 bytes) available to this Java virtual machine on the current file store.
*
* Identical to:
*
*
*
* freeSpaceKb(FileUtils.current().getAbsolutePath())
*
*
* @return the amount of free drive space on the drive or volume in kilobytes
* @throws IOException if an I/O error occurs.
* @throws IllegalArgumentException if the path is invalid.
* @since 2.0
* @deprecated As of 2.6 deprecated without replacement. Please use {@link java.nio.file.FileStore#getUsableSpace()}.
*/
@Deprecated
public static long freeSpaceKb() throws IOException {
return freeSpaceKb(-1);
}
/**
* Gets the number of kibibytes (1024 bytes) available to this Java virtual machine on the current file store.
*
* Identical to:
*
*
*
* freeSpaceKb(FileUtils.current().getAbsolutePath())
*
*
* @param timeout ignored.
* @return the amount of free drive space on the drive or volume in kilobytes
* @throws IOException if an I/O error occurs.
* @throws IllegalArgumentException if the path is invalid.
* @since 2.0
* @deprecated As of 2.6 deprecated without replacement. Please use {@link java.nio.file.FileStore#getUsableSpace()}.
*/
@Deprecated
public static long freeSpaceKb(final long timeout) throws IOException {
return freeSpaceKb(FileUtils.current().getAbsolutePath(), timeout);
}
/**
* Gets the number of kibibytes (1024 bytes) available to this Java virtual machine on the given file store.
*
*
* FileSystemUtils.freeSpaceKb("C:"); // Windows
* FileSystemUtils.freeSpaceKb("/volume"); // *nix
*
*
* @param path the path to get free space for, not null, not empty on UNIX
* @return the amount of free drive space on the drive or volume in kilobytes
* @throws IOException if an I/O error occurs.
* @throws IllegalArgumentException if the path is invalid.
* @since 1.2, enhanced OS support in 1.3
* @deprecated As of 2.6 deprecated without replacement. Please use {@link java.nio.file.FileStore#getUsableSpace()}.
*/
@Deprecated
public static long freeSpaceKb(final String path) throws IOException {
return freeSpaceKb(path, -1);
}
/**
* Gets the number of kibibytes (1024 bytes) available to this Java virtual machine on the given file store.
*
*
* FileSystemUtils.freeSpaceKb("C:"); // Windows
* FileSystemUtils.freeSpaceKb("/volume"); // *nix
*
*
* @param path the path to get free space for, not null, not empty on UNIX
* @param timeout ignored.
* @return the amount of free drive space on the drive or volume in kilobytes
* @throws IOException if an I/O error occurs.
* @throws IllegalArgumentException if the path is invalid.
* @since 2.0
* @deprecated As of 2.6 deprecated without replacement. Please use {@link java.nio.file.FileStore#getUsableSpace()}.
*/
@Deprecated
public static long freeSpaceKb(final String path, final long timeout) throws IOException {
return getFreeSpace(path) / FileUtils.ONE_KB;
}
/**
* Gets the number of bytes available to this Java virtual machine on the given file store.
*
*
* FileSystemUtils.freeSpace("C:"); // Windows
* FileSystemUtils.freeSpace("/volume"); // *nix
*
*
* @param pathStr the path to get free space for, not null, not empty on UNIX
* @return the amount of free drive space on the drive or volume
* @throws IOException if an I/O error occurs.
* @throws IllegalArgumentException if the path is invalid.
*/
static long getFreeSpace(final String pathStr) throws IOException {
final Path path = Paths.get(Objects.requireNonNull(pathStr, "pathStr"));
if (Files.exists(path)) {
// Need an absolute path for input like "" to work
return Files.getFileStore(path.toAbsolutePath()).getUsableSpace();
// return path.toAbsolutePath().toFile().getUsableSpace();
}
throw new IllegalArgumentException(path.toString());
}
/**
* Instances should NOT be constructed in standard programming.
*
* @deprecated TODO Make private in 3.0.
*/
@Deprecated
public FileSystemUtils() {
// empty
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/FileUtils.java 0100644 0000000 0000000 00000503747 14603604450 026320 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.io.UncheckedIOException;
import java.math.BigInteger;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.charset.UnsupportedCharsetException;
import java.nio.file.CopyOption;
import java.nio.file.DirectoryStream;
import java.nio.file.FileVisitOption;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.NotDirectoryException;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.ZoneId;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.ChronoLocalDateTime;
import java.time.chrono.ChronoZonedDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;
import java.util.zip.Checksum;
import org.apache.commons.io.file.AccumulatorPathVisitor;
import org.apache.commons.io.file.Counters;
import org.apache.commons.io.file.PathFilter;
import org.apache.commons.io.file.PathUtils;
import org.apache.commons.io.file.StandardDeleteOption;
import org.apache.commons.io.filefilter.FileEqualsFileFilter;
import org.apache.commons.io.filefilter.FileFileFilter;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.SuffixFileFilter;
import org.apache.commons.io.filefilter.TrueFileFilter;
import org.apache.commons.io.function.IOConsumer;
import org.apache.commons.io.function.Uncheck;
/**
* General file manipulation utilities.
*
* Facilities are provided in the following areas:
*
*
* - writing to a file
*
- reading from a file
*
- make a directory including parent directories
*
- copying files and directories
*
- deleting files and directories
*
- converting to and from a URL
*
- listing files and directories by filter and extension
*
- comparing file content
*
- file last changed date
*
- calculating a checksum
*
*
* Note that a specific charset should be specified whenever possible. Relying on the platform default means that the
* code is Locale-dependent. Only use the default if the files are known to always use the platform default.
*
*
* {@link SecurityException} are not documented in the Javadoc.
*
*
* Provenance: Excalibur, Alexandria, Commons-Utils
*
*/
public class FileUtils {
/**
* The number of bytes in a kilobyte.
*/
public static final long ONE_KB = 1024;
/**
* The number of bytes in a kilobyte.
*
* @since 2.4
*/
public static final BigInteger ONE_KB_BI = BigInteger.valueOf(ONE_KB);
/**
* The number of bytes in a megabyte.
*/
public static final long ONE_MB = ONE_KB * ONE_KB;
/**
* The number of bytes in a megabyte.
*
* @since 2.4
*/
public static final BigInteger ONE_MB_BI = ONE_KB_BI.multiply(ONE_KB_BI);
/**
* The number of bytes in a gigabyte.
*/
public static final long ONE_GB = ONE_KB * ONE_MB;
/**
* The number of bytes in a gigabyte.
*
* @since 2.4
*/
public static final BigInteger ONE_GB_BI = ONE_KB_BI.multiply(ONE_MB_BI);
/**
* The number of bytes in a terabyte.
*/
public static final long ONE_TB = ONE_KB * ONE_GB;
/**
* The number of bytes in a terabyte.
*
* @since 2.4
*/
public static final BigInteger ONE_TB_BI = ONE_KB_BI.multiply(ONE_GB_BI);
/**
* The number of bytes in a petabyte.
*/
public static final long ONE_PB = ONE_KB * ONE_TB;
/**
* The number of bytes in a petabyte.
*
* @since 2.4
*/
public static final BigInteger ONE_PB_BI = ONE_KB_BI.multiply(ONE_TB_BI);
/**
* The number of bytes in an exabyte.
*/
public static final long ONE_EB = ONE_KB * ONE_PB;
/**
* The number of bytes in an exabyte.
*
* @since 2.4
*/
public static final BigInteger ONE_EB_BI = ONE_KB_BI.multiply(ONE_PB_BI);
/**
* The number of bytes in a zettabyte.
*/
public static final BigInteger ONE_ZB = BigInteger.valueOf(ONE_KB).multiply(BigInteger.valueOf(ONE_EB));
/**
* The number of bytes in a yottabyte.
*/
public static final BigInteger ONE_YB = ONE_KB_BI.multiply(ONE_ZB);
/**
* An empty array of type {@link File}.
*/
public static final File[] EMPTY_FILE_ARRAY = {};
/**
* Returns a human-readable version of the file size, where the input represents a specific number of bytes.
*
* If the size is over 1GB, the size is returned as the number of whole GB, i.e. the size is rounded down to the
* nearest GB boundary.
*
*
* Similarly for the 1MB and 1KB boundaries.
*
*
* @param size the number of bytes
* @return a human-readable display value (includes units - EB, PB, TB, GB, MB, KB or bytes)
* @throws NullPointerException if the given {@link BigInteger} is {@code null}.
* @see IO-226 - should the rounding be changed?
* @since 2.4
*/
// See https://issues.apache.org/jira/browse/IO-226 - should the rounding be changed?
public static String byteCountToDisplaySize(final BigInteger size) {
Objects.requireNonNull(size, "size");
final String displaySize;
if (size.divide(ONE_EB_BI).compareTo(BigInteger.ZERO) > 0) {
displaySize = size.divide(ONE_EB_BI) + " EB";
} else if (size.divide(ONE_PB_BI).compareTo(BigInteger.ZERO) > 0) {
displaySize = size.divide(ONE_PB_BI) + " PB";
} else if (size.divide(ONE_TB_BI).compareTo(BigInteger.ZERO) > 0) {
displaySize = size.divide(ONE_TB_BI) + " TB";
} else if (size.divide(ONE_GB_BI).compareTo(BigInteger.ZERO) > 0) {
displaySize = size.divide(ONE_GB_BI) + " GB";
} else if (size.divide(ONE_MB_BI).compareTo(BigInteger.ZERO) > 0) {
displaySize = size.divide(ONE_MB_BI) + " MB";
} else if (size.divide(ONE_KB_BI).compareTo(BigInteger.ZERO) > 0) {
displaySize = size.divide(ONE_KB_BI) + " KB";
} else {
displaySize = size + " bytes";
}
return displaySize;
}
/**
* Returns a human-readable version of the file size, where the input represents a specific number of bytes.
*
* If the size is over 1GB, the size is returned as the number of whole GB, i.e. the size is rounded down to the
* nearest GB boundary.
*
*
* Similarly for the 1MB and 1KB boundaries.
*
*
* @param size the number of bytes
* @return a human-readable display value (includes units - EB, PB, TB, GB, MB, KB or bytes)
* @see IO-226 - should the rounding be changed?
*/
// See https://issues.apache.org/jira/browse/IO-226 - should the rounding be changed?
public static String byteCountToDisplaySize(final long size) {
return byteCountToDisplaySize(BigInteger.valueOf(size));
}
/**
* Returns a human-readable version of the file size, where the input represents a specific number of bytes.
*
* If the size is over 1GB, the size is returned as the number of whole GB, i.e. the size is rounded down to the
* nearest GB boundary.
*
*
* Similarly for the 1MB and 1KB boundaries.
*
*
* @param size the number of bytes
* @return a human-readable display value (includes units - EB, PB, TB, GB, MB, KB or bytes)
* @see IO-226 - should the rounding be changed?
* @since 2.12.0
*/
// See https://issues.apache.org/jira/browse/IO-226 - should the rounding be changed?
public static String byteCountToDisplaySize(final Number size) {
return byteCountToDisplaySize(size.longValue());
}
/**
* Requires that the given {@link File} object
* points to an actual file (not a directory) in the file system,
* and throws a {@link FileNotFoundException} if it doesn't.
* It throws an IllegalArgumentException if the object points to a directory.
*
* @param file The {@link File} to check.
* @param name The parameter name to use in the exception message.
* @throws FileNotFoundException if the file does not exist
* @throws NullPointerException if the given {@link File} is {@code null}.
* @throws IllegalArgumentException if the given {@link File} is not a file.
*/
private static void checkFileExists(final File file, final String name) throws FileNotFoundException {
Objects.requireNonNull(file, name);
if (!file.isFile()) {
if (file.exists()) {
throw new IllegalArgumentException("Parameter '" + name + "' is not a file: " + file);
}
if (!Files.isSymbolicLink(file.toPath())) {
throw new FileNotFoundException("Source '" + file + "' does not exist");
}
}
}
private static File checkIsFile(final File file, final String name) {
if (file.isFile()) {
return file;
}
throw new IllegalArgumentException(String.format("Parameter '%s' is not a file: %s", name, file));
}
/**
* Computes the checksum of a file using the specified checksum object. Multiple files may be checked using one
* {@link Checksum} instance if desired simply by reusing the same checksum object. For example:
*
*
* long checksum = FileUtils.checksum(file, new CRC32()).getValue();
*
*
* @param file the file to checksum, must not be {@code null}
* @param checksum the checksum object to be used, must not be {@code null}
* @return the checksum specified, updated with the content of the file
* @throws NullPointerException if the given {@link File} is {@code null}.
* @throws NullPointerException if the given {@link Checksum} is {@code null}.
* @throws IllegalArgumentException if the given {@link File} is not a file.
* @throws FileNotFoundException if the file does not exist
* @throws IOException if an IO error occurs reading the file.
* @since 1.3
*/
public static Checksum checksum(final File file, final Checksum checksum) throws IOException {
checkFileExists(file, "file");
Objects.requireNonNull(checksum, "checksum");
try (InputStream inputStream = new CheckedInputStream(Files.newInputStream(file.toPath()), checksum)) {
IOUtils.consume(inputStream);
}
return checksum;
}
/**
* Computes the checksum of a file using the CRC32 checksum routine.
* The value of the checksum is returned.
*
* @param file the file to checksum, must not be {@code null}
* @return the checksum value
* @throws NullPointerException if the given {@link File} is {@code null}.
* @throws IllegalArgumentException if the given {@link File} does not exist or is not a file.
* @throws IOException if an IO error occurs reading the file.
* @since 1.3
*/
public static long checksumCRC32(final File file) throws IOException {
return checksum(file, new CRC32()).getValue();
}
/**
* Cleans a directory without deleting it.
*
* @param directory directory to clean
* @throws NullPointerException if the given {@link File} is {@code null}.
* @throws IllegalArgumentException if directory does not exist or is not a directory.
* @throws IOException if an I/O error occurs.
* @see #forceDelete(File)
*/
public static void cleanDirectory(final File directory) throws IOException {
IOConsumer.forAll(FileUtils::forceDelete, listFiles(directory, null));
}
/**
* Cleans a directory without deleting it.
*
* @param directory directory to clean, must not be {@code null}
* @throws NullPointerException if the given {@link File} is {@code null}.
* @throws IllegalArgumentException if directory does not exist or is not a directory.
* @throws IOException if an I/O error occurs.
* @see #forceDeleteOnExit(File)
*/
private static void cleanDirectoryOnExit(final File directory) throws IOException {
IOConsumer.forAll(FileUtils::forceDeleteOnExit, listFiles(directory, null));
}
/**
* Tests whether the contents of two files are equal.
*
* This method checks to see if the two files are different lengths or if they point to the same file, before
* resorting to byte-by-byte comparison of the contents.
*
*
* @param file1 the first file
* @param file2 the second file
* @return true if the content of the files are equal or they both don't exist, false otherwise
* @throws IllegalArgumentException when an input is not a file.
* @throws IOException If an I/O error occurs.
* @see PathUtils#fileContentEquals(Path,Path)
*/
public static boolean contentEquals(final File file1, final File file2) throws IOException {
if (file1 == null && file2 == null) {
return true;
}
if (file1 == null || file2 == null) {
return false;
}
final boolean file1Exists = file1.exists();
if (file1Exists != file2.exists()) {
return false;
}
if (!file1Exists) {
// two not existing files are equal
return true;
}
checkIsFile(file1, "file1");
checkIsFile(file2, "file2");
if (file1.length() != file2.length()) {
// lengths differ, cannot be equal
return false;
}
if (file1.getCanonicalFile().equals(file2.getCanonicalFile())) {
// same file
return true;
}
return PathUtils.fileContentEquals(file1.toPath(), file2.toPath());
}
/**
* Compares the contents of two files to determine if they are equal or not.
*
* This method checks to see if the two files point to the same file,
* before resorting to line-by-line comparison of the contents.
*
*
* @param file1 the first file
* @param file2 the second file
* @param charsetName the name of the requested charset.
* May be null, in which case the platform default is used
* @return true if the content of the files are equal or neither exists,
* false otherwise
* @throws IllegalArgumentException when an input is not a file.
* @throws IOException in case of an I/O error.
* @throws UnsupportedCharsetException If the named charset is unavailable (unchecked exception).
* @see IOUtils#contentEqualsIgnoreEOL(Reader, Reader)
* @since 2.2
*/
public static boolean contentEqualsIgnoreEOL(final File file1, final File file2, final String charsetName)
throws IOException {
if (file1 == null && file2 == null) {
return true;
}
if (file1 == null || file2 == null) {
return false;
}
final boolean file1Exists = file1.exists();
if (file1Exists != file2.exists()) {
return false;
}
if (!file1Exists) {
// two not existing files are equal
return true;
}
checkFileExists(file1, "file1");
checkFileExists(file2, "file2");
if (file1.getCanonicalFile().equals(file2.getCanonicalFile())) {
// same file
return true;
}
final Charset charset = Charsets.toCharset(charsetName);
try (Reader input1 = new InputStreamReader(Files.newInputStream(file1.toPath()), charset);
Reader input2 = new InputStreamReader(Files.newInputStream(file2.toPath()), charset)) {
return IOUtils.contentEqualsIgnoreEOL(input1, input2);
}
}
/**
* Converts a Collection containing {@link File} instances into array
* representation. This is to account for the difference between
* File.listFiles() and FileUtils.listFiles().
*
* @param files a Collection containing {@link File} instances
* @return an array of {@link File}
*/
public static File[] convertFileCollectionToFileArray(final Collection files) {
return files.toArray(EMPTY_FILE_ARRAY);
}
/**
* Copies a whole directory to a new location, preserving the file dates.
*
* This method copies the specified directory and all its child directories and files to the specified destination.
* The destination is the new location and name of the directory. That is, copying /home/bar to /tmp/bang
* copies the contents of /home/bar into /tmp/bang. It does not create /tmp/bang/bar.
*
*
* The destination directory is created if it does not exist. If the destination directory does exist, then this
* method merges the source with the destination, with the source taking precedence.
*
*
* Note: This method tries to preserve the file's last
* modified date/times using {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However it is
* not guaranteed that the operation will succeed. If the modification operation fails, it falls back to
* {@link File#setLastModified(long)}. If that fails, the method throws IOException.
*
*
* Symbolic links in the source directory are copied to new symbolic links in the destination
* directory that point to the original target. The target of the link is not copied unless
* it is also under the source directory. Even if it is under the source directory, the new symbolic
* link in the destination points to the original target in the source directory, not to the
* newly created copy of the target.
*
*
* @param srcDir an existing directory to copy, must not be {@code null}.
* @param destDir the new directory, must not be {@code null}.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IllegalArgumentException if {@code srcDir} exists but is not a directory,
* the source and the destination directory are the same
* @throws FileNotFoundException if the source does not exist.
* @throws IOException if an error occurs, the destination is not writable, or setting the last-modified time didn't succeed
* @since 1.1
*/
public static void copyDirectory(final File srcDir, final File destDir) throws IOException {
copyDirectory(srcDir, destDir, true);
}
/**
* Copies a whole directory to a new location.
*
* This method copies the contents of the specified source directory to within the specified destination directory.
*
*
* The destination directory is created if it does not exist. If the destination directory does exist, then this
* method merges the source with the destination, with the source taking precedence.
*
*
* Note: Setting {@code preserveFileDate} to {@code true} tries to preserve the files' last
* modified date/times using {@link File#setLastModified(long)}. However it is not guaranteed that those operations
* will succeed. If the modification operation fails, the method throws IOException.
*
*
* @param srcDir an existing directory to copy, must not be {@code null}.
* @param destDir the new directory, must not be {@code null}.
* @param preserveFileDate true if the file date of the copy should be the same as the original.
* @throws IllegalArgumentException if {@code srcDir} exists but is not a directory, or
* the source and the destination directory are the same
* @throws FileNotFoundException if the source does not exist.
* @throws IOException if an error occurs, the destination is not writable, or setting the last-modified time didn't succeed
* @since 1.1
*/
public static void copyDirectory(final File srcDir, final File destDir, final boolean preserveFileDate)
throws IOException {
copyDirectory(srcDir, destDir, null, preserveFileDate);
}
/**
* Copies a filtered directory to a new location preserving the file dates.
*
* This method copies the contents of the specified source directory to within the specified destination directory.
*
*
* The destination directory is created if it does not exist. If the destination directory does exist, then this
* method merges the source with the destination, with the source taking precedence.
*
*
* Note: This method tries to preserve the files' last modified date/times using
* {@link File#setLastModified(long)}. However it is not guaranteed that those operations will succeed. If the
* modification operation fails, the method throws IOException.
*
* Example: Copy directories only
*
*
* // only copy the directory structure
* FileUtils.copyDirectory(srcDir, destDir, DirectoryFileFilter.DIRECTORY);
*
*
* Example: Copy directories and txt files
*
*
* // Create a filter for ".txt" files
* IOFileFilter txtSuffixFilter = FileFilterUtils.suffixFileFilter(".txt");
* IOFileFilter txtFiles = FileFilterUtils.andFileFilter(FileFileFilter.FILE, txtSuffixFilter);
*
* // Create a filter for either directories or ".txt" files
* FileFilter filter = FileFilterUtils.orFileFilter(DirectoryFileFilter.DIRECTORY, txtFiles);
*
* // Copy using the filter
* FileUtils.copyDirectory(srcDir, destDir, filter);
*
*
* @param srcDir an existing directory to copy, must not be {@code null}.
* @param destDir the new directory, must not be {@code null}.
* @param filter the filter to apply, null means copy all directories and files should be the same as the original.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IllegalArgumentException if {@code srcDir} exists but is not a directory, or
* the source and the destination directory are the same
* @throws FileNotFoundException if the source does not exist.
* @throws IOException if an error occurs, the destination is not writable, or setting the last-modified time didn't succeed
* @since 1.4
*/
public static void copyDirectory(final File srcDir, final File destDir, final FileFilter filter)
throws IOException {
copyDirectory(srcDir, destDir, filter, true);
}
/**
* Copies a filtered directory to a new location.
*
* This method copies the contents of the specified source directory to within the specified destination directory.
*
*
* The destination directory is created if it does not exist. If the destination directory does exist, then this
* method merges the source with the destination, with the source taking precedence.
*
*
* Note: Setting {@code preserveFileDate} to {@code true} tries to preserve the file's last
* modified date/times using {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However, it is
* not guaranteed that the operation will succeed. If the modification operation fails it falls back to
* {@link File#setLastModified(long)}. If that fails, the method throws IOException.
*
* Example: Copy directories only
*
*
* // only copy the directory structure
* FileUtils.copyDirectory(srcDir, destDir, DirectoryFileFilter.DIRECTORY, false);
*
*
* Example: Copy directories and txt files
*
*
* // Create a filter for ".txt" files
* IOFileFilter txtSuffixFilter = FileFilterUtils.suffixFileFilter(".txt");
* IOFileFilter txtFiles = FileFilterUtils.andFileFilter(FileFileFilter.FILE, txtSuffixFilter);
*
* // Create a filter for either directories or ".txt" files
* FileFilter filter = FileFilterUtils.orFileFilter(DirectoryFileFilter.DIRECTORY, txtFiles);
*
* // Copy using the filter
* FileUtils.copyDirectory(srcDir, destDir, filter, false);
*
*
* @param srcDir an existing directory to copy, must not be {@code null}.
* @param destDir the new directory, must not be {@code null}.
* @param filter the filter to apply, null means copy all directories and files.
* @param preserveFileDate true if the file date of the copy should be the same as the original.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IllegalArgumentException if {@code srcDir} exists but is not a directory,
* the source and the destination directory are the same, or the destination is not writable
* @throws FileNotFoundException if the source does not exist.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @since 1.4
*/
public static void copyDirectory(final File srcDir, final File destDir, final FileFilter filter, final boolean preserveFileDate) throws IOException {
copyDirectory(srcDir, destDir, filter, preserveFileDate, StandardCopyOption.REPLACE_EXISTING, LinkOption.NOFOLLOW_LINKS);
}
/**
* Copies a filtered directory to a new location.
*
* This method copies the contents of the specified source directory to within the specified destination directory.
*
*
* The destination directory is created if it does not exist. If the destination directory does exist, then this
* method merges the source with the destination, with the source taking precedence.
*
*
* Note: Setting {@code preserveFileDate} to {@code true} tries to preserve the file's last
* modified date/times using {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However, it is
* not guaranteed that the operation will succeed. If the modification operation fails it falls back to
* {@link File#setLastModified(long)}. If that fails, the method throws IOException.
*
* Example: Copy directories only
*
*
* // only copy the directory structure
* FileUtils.copyDirectory(srcDir, destDir, DirectoryFileFilter.DIRECTORY, false);
*
*
* Example: Copy directories and txt files
*
*
* // Create a filter for ".txt" files
* IOFileFilter txtSuffixFilter = FileFilterUtils.suffixFileFilter(".txt");
* IOFileFilter txtFiles = FileFilterUtils.andFileFilter(FileFileFilter.FILE, txtSuffixFilter);
*
* // Create a filter for either directories or ".txt" files
* FileFilter filter = FileFilterUtils.orFileFilter(DirectoryFileFilter.DIRECTORY, txtFiles);
*
* // Copy using the filter
* FileUtils.copyDirectory(srcDir, destDir, filter, false);
*
*
* @param srcDir an existing directory to copy, must not be {@code null}
* @param destDir the new directory, must not be {@code null}
* @param fileFilter the filter to apply, null means copy all directories and files
* @param preserveFileDate true if the file date of the copy should be the same as the original
* @param copyOptions options specifying how the copy should be done, for example {@link StandardCopyOption}.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IllegalArgumentException if {@code srcDir} exists but is not a directory, or
* the source and the destination directory are the same
* @throws FileNotFoundException if the source does not exist.
* @throws IOException if an error occurs, the destination is not writable, or setting the last-modified time didn't succeed
* @since 2.8.0
*/
public static void copyDirectory(final File srcDir, final File destDir, final FileFilter fileFilter, final boolean preserveFileDate,
final CopyOption... copyOptions) throws IOException {
Objects.requireNonNull(destDir, "destination");
requireDirectoryExists(srcDir, "srcDir");
requireCanonicalPathsNotEquals(srcDir, destDir);
// Cater for destination being directory within the source directory (see IO-141)
List exclusionList = null;
final String srcDirCanonicalPath = srcDir.getCanonicalPath();
final String destDirCanonicalPath = destDir.getCanonicalPath();
if (destDirCanonicalPath.startsWith(srcDirCanonicalPath)) {
final File[] srcFiles = listFiles(srcDir, fileFilter);
if (srcFiles.length > 0) {
exclusionList = new ArrayList<>(srcFiles.length);
for (final File srcFile : srcFiles) {
exclusionList.add(new File(destDir, srcFile.getName()).getCanonicalPath());
}
}
}
doCopyDirectory(srcDir, destDir, fileFilter, exclusionList, preserveFileDate, copyOptions);
}
/**
* Copies a directory to within another directory preserving the file dates.
*
* This method copies the source directory and all its contents to a directory of the same name in the specified
* destination directory.
*
*
* The destination directory is created if it does not exist. If the destination directory does exist, then this
* method merges the source with the destination, with the source taking precedence.
*
*
* Note: Setting {@code preserveFileDate} to {@code true} tries to preserve the file's last
* modified date/times using {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However, it is
* not guaranteed that the operation will succeed. If the modification operation fails it falls back to
* {@link File#setLastModified(long)} and if that fails, the method throws IOException.
*
*
* @param sourceDir an existing directory to copy, must not be {@code null}.
* @param destinationDir the directory to place the copy in, must not be {@code null}.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IllegalArgumentException if the source or destination is invalid.
* @throws FileNotFoundException if the source does not exist.
* @throws IOException if an error occurs, the destination is not writable, or setting the last-modified time didn't succeed
* @since 1.2
*/
public static void copyDirectoryToDirectory(final File sourceDir, final File destinationDir) throws IOException {
Objects.requireNonNull(sourceDir, "sourceDir");
requireDirectoryIfExists(destinationDir, "destinationDir");
copyDirectory(sourceDir, new File(destinationDir, sourceDir.getName()), true);
}
/**
* Copies a file to a new location preserving the file date.
*
* This method copies the contents of the specified source file to the specified destination file. The directory
* holding the destination file is created if it does not exist. If the destination file exists, then this method
* overwrites it. A symbolic link is resolved before copying so the new file is not a link.
*
*
* Note: This method tries to preserve the file's last modified date/times using
* {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However, it is not guaranteed that the
* operation will succeed. If the modification operation fails, it falls back to
* {@link File#setLastModified(long)}, and if that fails, the method throws IOException.
*
*
* @param srcFile an existing file to copy, must not be {@code null}.
* @param destFile the new file, must not be {@code null}.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IOException if source or destination is invalid.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @throws IOException if the output file length is not the same as the input file length after the copy completes.
* @see #copyFileToDirectory(File, File)
* @see #copyFile(File, File, boolean)
*/
public static void copyFile(final File srcFile, final File destFile) throws IOException {
copyFile(srcFile, destFile, StandardCopyOption.REPLACE_EXISTING);
}
/**
* Copies an existing file to a new file location.
*
* This method copies the contents of the specified source file to the specified destination file. The directory
* holding the destination file is created if it does not exist. If the destination file exists, then this method
* overwrites it. A symbolic link is resolved before copying so the new file is not a link.
*
*
* Note: Setting {@code preserveFileDate} to {@code true} tries to preserve the file's last
* modified date/times using {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However, it is
* not guaranteed that the operation will succeed. If the modification operation fails, it falls back to
* {@link File#setLastModified(long)}, and if that fails, the method throws IOException.
*
*
* @param srcFile an existing file to copy, must not be {@code null}.
* @param destFile the new file, must not be {@code null}.
* @param preserveFileDate true if the file date of the copy should be the same as the original.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IOException if source or destination is invalid.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @throws IOException if the output file length is not the same as the input file length after the copy completes
* @see #copyFile(File, File, boolean, CopyOption...)
*/
public static void copyFile(final File srcFile, final File destFile, final boolean preserveFileDate) throws IOException {
copyFile(srcFile, destFile, preserveFileDate, StandardCopyOption.REPLACE_EXISTING);
}
/**
* Copies the contents of a file to a new location.
*
* This method copies the contents of the specified source file to the specified destination file. The directory
* holding the destination file is created if it does not exist. If the destination file exists, you can overwrite
* it with {@link StandardCopyOption#REPLACE_EXISTING}.
*
*
*
* By default, a symbolic link is resolved before copying so the new file is not a link.
* To copy symbolic links as links, you can pass {@code LinkOption.NO_FOLLOW_LINKS} as the last argument.
*
*
*
* Note: Setting {@code preserveFileDate} to {@code true} tries to preserve the file's last
* modified date/times using {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However, it is
* not guaranteed that the operation will succeed. If the modification operation fails, it falls back to
* {@link File#setLastModified(long)}, and if that fails, the method throws IOException.
*
*
* @param srcFile an existing file to copy, must not be {@code null}.
* @param destFile the new file, must not be {@code null}.
* @param preserveFileDate true if the file date of the copy should be the same as the original.
* @param copyOptions options specifying how the copy should be done, for example {@link StandardCopyOption}.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws FileNotFoundException if the source does not exist.
* @throws IllegalArgumentException if {@code srcFile} or {@code destFile} is not a file
* @throws IOException if the output file length is not the same as the input file length after the copy completes.
* @throws IOException if an I/O error occurs, setting the last-modified time didn't succeed,
* or the destination is not writable
* @see #copyFileToDirectory(File, File, boolean)
* @since 2.8.0
*/
public static void copyFile(final File srcFile, final File destFile, final boolean preserveFileDate, final CopyOption... copyOptions) throws IOException {
Objects.requireNonNull(destFile, "destination");
checkFileExists(srcFile, "srcFile");
requireCanonicalPathsNotEquals(srcFile, destFile);
createParentDirectories(destFile);
if (destFile.exists()) {
checkFileExists(destFile, "destFile");
}
final Path srcPath = srcFile.toPath();
Files.copy(srcPath, destFile.toPath(), copyOptions);
// On Windows, the last modified time is copied by default.
if (preserveFileDate && !Files.isSymbolicLink(srcPath) && !setTimes(srcFile, destFile)) {
throw new IOException("Cannot set the file time.");
}
}
/**
* Copies a file to a new location.
*
* This method copies the contents of the specified source file to the specified destination file. The directory
* holding the destination file is created if it does not exist. If the destination file exists, you can overwrite
* it if you use {@link StandardCopyOption#REPLACE_EXISTING}.
*
*
* @param srcFile an existing file to copy, must not be {@code null}.
* @param destFile the new file, must not be {@code null}.
* @param copyOptions options specifying how the copy should be done, for example {@link StandardCopyOption}..
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws FileNotFoundException if the source does not exist.
* @throws IllegalArgumentException if source is not a file.
* @throws IOException if an I/O error occurs.
* @see StandardCopyOption
* @since 2.9.0
*/
public static void copyFile(final File srcFile, final File destFile, final CopyOption... copyOptions) throws IOException {
copyFile(srcFile, destFile, true, copyOptions);
}
/**
* Copies bytes from a {@link File} to an {@link OutputStream}.
*
* This method buffers the input internally, so there is no need to use a {@link BufferedInputStream}.
*
*
* @param input the {@link File} to read.
* @param output the {@link OutputStream} to write.
* @return the number of bytes copied
* @throws NullPointerException if the File is {@code null}.
* @throws NullPointerException if the OutputStream is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 2.1
*/
public static long copyFile(final File input, final OutputStream output) throws IOException {
try (InputStream fis = Files.newInputStream(input.toPath())) {
return IOUtils.copyLarge(fis, output);
}
}
/**
* Copies a file to a directory preserving the file date.
*
* This method copies the contents of the specified source file to a file of the same name in the specified
* destination directory. The destination directory is created if it does not exist. If the destination file exists,
* then this method will overwrite it.
*
*
* Note: This method tries to preserve the file's last modified date/times using
* {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However, it is not guaranteed that the
* operation will succeed. If the modification operation fails it falls back to
* {@link File#setLastModified(long)} and if that fails, the method throws IOException.
*
*
* @param srcFile an existing file to copy, must not be {@code null}.
* @param destDir the directory to place the copy in, must not be {@code null}.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IllegalArgumentException if source or destination is invalid.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @see #copyFile(File, File, boolean)
*/
public static void copyFileToDirectory(final File srcFile, final File destDir) throws IOException {
copyFileToDirectory(srcFile, destDir, true);
}
/**
* Copies a file to a directory optionally preserving the file date.
*
* This method copies the contents of the specified source file to a file of the same name in the specified
* destination directory. The destination directory is created if it does not exist. If the destination file exists,
* then this method will overwrite it.
*
*
* Note: Setting {@code preserveFileDate} to {@code true} tries to preserve the file's last
* modified date/times using {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However, it is
* not guaranteed that the operation will succeed. If the modification operation fails it falls back to
* {@link File#setLastModified(long)} and if that fails, the method throws IOException.
*
*
* @param sourceFile an existing file to copy, must not be {@code null}.
* @param destinationDir the directory to place the copy in, must not be {@code null}.
* @param preserveFileDate true if the file date of the copy should be the same as the original.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @throws IOException if the output file length is not the same as the input file length after the copy completes.
* @see #copyFile(File, File, CopyOption...)
* @since 1.3
*/
public static void copyFileToDirectory(final File sourceFile, final File destinationDir, final boolean preserveFileDate) throws IOException {
Objects.requireNonNull(sourceFile, "sourceFile");
requireDirectoryIfExists(destinationDir, "destinationDir");
copyFile(sourceFile, new File(destinationDir, sourceFile.getName()), preserveFileDate);
}
/**
* Copies bytes from an {@link InputStream} {@code source} to a file
* {@code destination}. The directories up to {@code destination}
* will be created if they don't already exist. {@code destination}
* will be overwritten if it already exists.
*
* The {@code source} stream is closed.
*
*
* See {@link #copyToFile(InputStream, File)} for a method that does not close the input stream.
*
*
* @param source the {@link InputStream} to copy bytes from, must not be {@code null}, will be closed
* @param destination the non-directory {@link File} to write bytes to
* (possibly overwriting), must not be {@code null}
* @throws IOException if {@code destination} is a directory
* @throws IOException if {@code destination} cannot be written
* @throws IOException if {@code destination} needs creating but can't be
* @throws IOException if an IO error occurs during copying
* @since 2.0
*/
public static void copyInputStreamToFile(final InputStream source, final File destination) throws IOException {
try (InputStream inputStream = source) {
copyToFile(inputStream, destination);
}
}
/**
* Copies a file or directory to within another directory preserving the file dates.
*
* This method copies the source file or directory, along with all its contents, to a directory of the same name in the
* specified destination directory.
*
*
* The destination directory is created if it does not exist. If the destination directory does exist, then this method
* merges the source with the destination, with the source taking precedence.
*
*
* Note: Setting {@code preserveFileDate} to {@code true} tries to preserve the file's last
* modified date/times using {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However, it is
* not guaranteed that the operation will succeed. If the modification operation fails it falls back to
* {@link File#setLastModified(long)} and if that fails, the method throws IOException.
*
*
* @param sourceFile an existing file or directory to copy, must not be {@code null}.
* @param destinationDir the directory to place the copy in, must not be {@code null}.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IllegalArgumentException if the source or destination is invalid.
* @throws FileNotFoundException if the source does not exist.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @see #copyDirectoryToDirectory(File, File)
* @see #copyFileToDirectory(File, File)
* @since 2.6
*/
public static void copyToDirectory(final File sourceFile, final File destinationDir) throws IOException {
Objects.requireNonNull(sourceFile, "sourceFile");
if (sourceFile.isFile()) {
copyFileToDirectory(sourceFile, destinationDir);
} else if (sourceFile.isDirectory()) {
copyDirectoryToDirectory(sourceFile, destinationDir);
} else {
throw new FileNotFoundException("The source " + sourceFile + " does not exist");
}
}
/**
* Copies a files to a directory preserving each file's date.
*
* This method copies the contents of the specified source files
* to a file of the same name in the specified destination directory.
* The destination directory is created if it does not exist.
* If the destination file exists, then this method will overwrite it.
*
*
* Note: This method tries to preserve the file's last
* modified date/times using {@link BasicFileAttributeView#setTimes(FileTime, FileTime, FileTime)}. However, it is
* not guaranteed that the operation will succeed. If the modification operation fails it falls back to
* {@link File#setLastModified(long)} and if that fails, the method throws IOException.
*
*
* @param sourceIterable existing files to copy, must not be {@code null}.
* @param destinationDir the directory to place the copies in, must not be {@code null}.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IOException if source or destination is invalid.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @see #copyFileToDirectory(File, File)
* @since 2.6
*/
public static void copyToDirectory(final Iterable sourceIterable, final File destinationDir) throws IOException {
Objects.requireNonNull(sourceIterable, "sourceIterable");
for (final File src : sourceIterable) {
copyFileToDirectory(src, destinationDir);
}
}
/**
* Copies bytes from an {@link InputStream} source to a {@link File} destination. The directories
* up to {@code destination} will be created if they don't already exist. {@code destination} will be
* overwritten if it already exists. The {@code source} stream is left open, e.g. for use with
* {@link java.util.zip.ZipInputStream ZipInputStream}. See {@link #copyInputStreamToFile(InputStream, File)} for a
* method that closes the input stream.
*
* @param inputStream the {@link InputStream} to copy bytes from, must not be {@code null}
* @param file the non-directory {@link File} to write bytes to (possibly overwriting), must not be
* {@code null}
* @throws NullPointerException if the InputStream is {@code null}.
* @throws NullPointerException if the File is {@code null}.
* @throws IllegalArgumentException if the file object is a directory.
* @throws IllegalArgumentException if the file is not writable.
* @throws IOException if the directories could not be created.
* @throws IOException if an IO error occurs during copying.
* @since 2.5
*/
public static void copyToFile(final InputStream inputStream, final File file) throws IOException {
try (OutputStream out = newOutputStream(file, false)) {
IOUtils.copy(inputStream, out);
}
}
/**
* Copies bytes from the URL {@code source} to a file
* {@code destination}. The directories up to {@code destination}
* will be created if they don't already exist. {@code destination}
* will be overwritten if it already exists.
*
* Warning: this method does not set a connection or read timeout and thus
* might block forever. Use {@link #copyURLToFile(URL, File, int, int)}
* with reasonable timeouts to prevent this.
*
*
* @param source the {@link URL} to copy bytes from, must not be {@code null}
* @param destination the non-directory {@link File} to write bytes to
* (possibly overwriting), must not be {@code null}
* @throws IOException if {@code source} URL cannot be opened
* @throws IOException if {@code destination} is a directory
* @throws IOException if {@code destination} cannot be written
* @throws IOException if {@code destination} needs creating but can't be
* @throws IOException if an IO error occurs during copying
*/
public static void copyURLToFile(final URL source, final File destination) throws IOException {
final Path path = destination.toPath();
PathUtils.createParentDirectories(path);
PathUtils.copy(source::openStream, path, StandardCopyOption.REPLACE_EXISTING);
}
/**
* Copies bytes from the URL {@code source} to a file {@code destination}. The directories up to
* {@code destination} will be created if they don't already exist. {@code destination} will be
* overwritten if it already exists.
*
* @param source the {@link URL} to copy bytes from, must not be {@code null}
* @param destination the non-directory {@link File} to write bytes to (possibly overwriting), must not be
* {@code null}
* @param connectionTimeoutMillis the number of milliseconds until this method will time out if no connection could
* be established to the {@code source}
* @param readTimeoutMillis the number of milliseconds until this method will time out if no data could be read from
* the {@code source}
* @throws IOException if {@code source} URL cannot be opened
* @throws IOException if {@code destination} is a directory
* @throws IOException if {@code destination} cannot be written
* @throws IOException if {@code destination} needs creating but can't be
* @throws IOException if an IO error occurs during copying
* @since 2.0
*/
public static void copyURLToFile(final URL source, final File destination, final int connectionTimeoutMillis, final int readTimeoutMillis)
throws IOException {
try (CloseableURLConnection urlConnection = CloseableURLConnection.open(source)) {
urlConnection.setConnectTimeout(connectionTimeoutMillis);
urlConnection.setReadTimeout(readTimeoutMillis);
try (InputStream stream = urlConnection.getInputStream()) {
copyInputStreamToFile(stream, destination);
}
}
}
/**
* Creates all parent directories for a File object, including any necessary but non-existent parent directories. If a parent directory already exists or
* is null, nothing happens.
*
* @param file the File that may need parents, may be null.
* @return The parent directory, or {@code null} if the given File does have a parent.
* @throws IOException if the directory was not created along with all its parent directories.
* @throws SecurityException See {@link File#mkdirs()}.
* @since 2.9.0
*/
public static File createParentDirectories(final File file) throws IOException {
return mkdirs(getParentFile(file));
}
/**
* Gets the current directory.
*
* @return the current directory.
* @since 2.12.0
*/
public static File current() {
return PathUtils.current().toFile();
}
/**
* Decodes the specified URL as per RFC 3986, i.e. transforms
* percent-encoded octets to characters by decoding with the UTF-8 character
* set. This function is primarily intended for usage with
* {@link java.net.URL} which unfortunately does not enforce proper URLs. As
* such, this method will leniently accept invalid characters or malformed
* percent-encoded octets and simply pass them literally through to the
* result string. Except for rare edge cases, this will make unencoded URLs
* pass through unaltered.
*
* @param url The URL to decode, may be {@code null}.
* @return The decoded URL or {@code null} if the input was
* {@code null}.
*/
static String decodeUrl(final String url) {
String decoded = url;
if (url != null && url.indexOf('%') >= 0) {
final int n = url.length();
final StringBuilder builder = new StringBuilder();
final ByteBuffer byteBuffer = ByteBuffer.allocate(n);
for (int i = 0; i < n; ) {
if (url.charAt(i) == '%') {
try {
do {
final byte octet = (byte) Integer.parseInt(url.substring(i + 1, i + 3), 16);
byteBuffer.put(octet);
i += 3;
} while (i < n && url.charAt(i) == '%');
continue;
} catch (final IndexOutOfBoundsException | NumberFormatException ignored) {
// malformed percent-encoded octet, fall through and
// append characters literally
} finally {
if (byteBuffer.position() > 0) {
byteBuffer.flip();
builder.append(StandardCharsets.UTF_8.decode(byteBuffer).toString());
byteBuffer.clear();
}
}
}
builder.append(url.charAt(i++));
}
decoded = builder.toString();
}
return decoded;
}
/**
* Deletes the given File but throws an IOException if it cannot, unlike {@link File#delete()} which returns a
* boolean.
*
* @param file The file to delete.
* @return the given file.
* @throws NullPointerException if the parameter is {@code null}
* @throws IOException if the file cannot be deleted.
* @see File#delete()
* @since 2.9.0
*/
public static File delete(final File file) throws IOException {
Objects.requireNonNull(file, "file");
Files.delete(file.toPath());
return file;
}
/**
* Deletes a directory recursively.
*
* @param directory directory to delete
* @throws IOException in case deletion is unsuccessful
* @throws NullPointerException if the parameter is {@code null}
* @throws IllegalArgumentException if {@code directory} is not a directory
*/
public static void deleteDirectory(final File directory) throws IOException {
Objects.requireNonNull(directory, "directory");
if (!directory.exists()) {
return;
}
if (!isSymlink(directory)) {
cleanDirectory(directory);
}
delete(directory);
}
/**
* Schedules a directory recursively for deletion on JVM exit.
*
* @param directory directory to delete, must not be {@code null}
* @throws NullPointerException if the directory is {@code null}
* @throws IOException in case deletion is unsuccessful
*/
private static void deleteDirectoryOnExit(final File directory) throws IOException {
if (!directory.exists()) {
return;
}
directory.deleteOnExit();
if (!isSymlink(directory)) {
cleanDirectoryOnExit(directory);
}
}
/**
* Deletes a file, never throwing an exception. If file is a directory, delete it and all subdirectories.
*
* The difference between File.delete() and this method are:
*
*
* - A directory to be deleted does not have to be empty.
* - No exceptions are thrown when a file or directory cannot be deleted.
*
*
* @param file file or directory to delete, can be {@code null}
* @return {@code true} if the file or directory was deleted, otherwise
* {@code false}
* @since 1.4
*/
public static boolean deleteQuietly(final File file) {
if (file == null) {
return false;
}
try {
if (file.isDirectory()) {
cleanDirectory(file);
}
} catch (final Exception ignored) {
// ignore
}
try {
return file.delete();
} catch (final Exception ignored) {
return false;
}
}
/**
* Determines whether the {@code parent} directory contains the {@code child} element (a file or directory).
*
* Files are normalized before comparison.
*
*
* Edge cases:
*
* - A {@code directory} must not be null: if null, throw NullPointerException
* - A {@code directory} must be a directory: if not a directory, throw IllegalArgumentException
* - A directory does not contain itself: return false
* - A null child file is not contained in any parent: return false
*
*
* @param directory the file to consider as the parent.
* @param child the file to consider as the child.
* @return true is the candidate leaf is under by the specified composite. False otherwise.
* @throws IOException if an IO error occurs while checking the files.
* @throws NullPointerException if the parent is {@code null}.
* @throws IllegalArgumentException if the parent is not a directory.
* @see FilenameUtils#directoryContains(String, String)
* @since 2.2
*/
public static boolean directoryContains(final File directory, final File child) throws IOException {
requireDirectoryExists(directory, "directory");
if (child == null || !child.exists()) {
return false;
}
// Canonicalize paths (normalizes relative paths)
return FilenameUtils.directoryContains(directory.getCanonicalPath(), child.getCanonicalPath());
}
/**
* Internal copy directory method. Creates all destination parent directories,
* including any necessary but non-existent parent directories.
*
* @param srcDir the validated source directory, must not be {@code null}.
* @param destDir the validated destination directory, must not be {@code null}.
* @param fileFilter the filter to apply, null means copy all directories and files.
* @param exclusionList List of files and directories to exclude from the copy, may be null.
* @param preserveDirDate preserve the directories last modified dates.
* @param copyOptions options specifying how the copy should be done, see {@link StandardCopyOption}.
* @throws IOException if the directory was not created along with all its parent directories.
* @throws IllegalArgumentException if {@code destDir} is not writable
* @throws SecurityException See {@link File#mkdirs()}.
*/
private static void doCopyDirectory(final File srcDir, final File destDir, final FileFilter fileFilter, final List exclusionList,
final boolean preserveDirDate, final CopyOption... copyOptions) throws IOException {
// recurse dirs, copy files.
final File[] srcFiles = listFiles(srcDir, fileFilter);
requireDirectoryIfExists(destDir, "destDir");
mkdirs(destDir);
for (final File srcFile : srcFiles) {
final File dstFile = new File(destDir, srcFile.getName());
if (exclusionList == null || !exclusionList.contains(srcFile.getCanonicalPath())) {
if (srcFile.isDirectory()) {
doCopyDirectory(srcFile, dstFile, fileFilter, exclusionList, preserveDirDate, copyOptions);
} else {
copyFile(srcFile, dstFile, preserveDirDate, copyOptions);
}
}
}
// Do this last, as the above has probably affected directory metadata
if (preserveDirDate) {
setTimes(srcDir, destDir);
}
}
/**
* Deletes a file or directory. For a directory, delete it and all subdirectories.
*
* The difference between File.delete() and this method are:
*
*
* - The directory does not have to be empty.
* - You get an exception when a file or directory cannot be deleted.
*
*
* @param file file or directory to delete, must not be {@code null}.
* @throws NullPointerException if the file is {@code null}.
* @throws FileNotFoundException if the file was not found.
* @throws IOException in case deletion is unsuccessful.
*/
public static void forceDelete(final File file) throws IOException {
Objects.requireNonNull(file, "file");
final Counters.PathCounters deleteCounters;
try {
deleteCounters = PathUtils.delete(
file.toPath(), PathUtils.EMPTY_LINK_OPTION_ARRAY,
StandardDeleteOption.OVERRIDE_READ_ONLY);
} catch (final IOException ex) {
throw new IOException("Cannot delete file: " + file, ex);
}
if (deleteCounters.getFileCounter().get() < 1 && deleteCounters.getDirectoryCounter().get() < 1) {
// didn't find a file to delete.
throw new FileNotFoundException("File does not exist: " + file);
}
}
/**
* Schedules a file to be deleted when JVM exits.
* If file is directory delete it and all subdirectories.
*
* @param file file or directory to delete, must not be {@code null}.
* @throws NullPointerException if the file is {@code null}.
* @throws IOException in case deletion is unsuccessful.
*/
public static void forceDeleteOnExit(final File file) throws IOException {
Objects.requireNonNull(file, "file");
if (file.isDirectory()) {
deleteDirectoryOnExit(file);
} else {
file.deleteOnExit();
}
}
/**
* Creates all directories for a File object, including any necessary but non-existent parent directories. If the {@code directory} already exists or is
* null, nothing happens.
*
* Calls {@link File#mkdirs()} and throws an {@link IOException} on failure.
*
*
* @param directory the receiver for {@code mkdirs()}. If the {@code directory} already exists or is null, nothing happens.
* @throws IOException if the directory was not created along with all its parent directories.
* @throws IOException if the given file object is not a directory.
* @throws SecurityException See {@link File#mkdirs()}.
* @see File#mkdirs()
*/
public static void forceMkdir(final File directory) throws IOException {
mkdirs(directory);
}
/**
* Creates all directories for a File object, including any necessary but non-existent parent directories. If the parent directory already exists or is
* null, nothing happens.
*
* Calls {@link File#mkdirs()} for the parent of {@code file}.
*
*
* @param file file with parents to create, must not be {@code null}.
* @throws NullPointerException if the file is {@code null}.
* @throws IOException if the directory was not created along with all its parent directories.
* @throws SecurityException See {@link File#mkdirs()}.
* @see File#mkdirs()
* @since 2.5
*/
public static void forceMkdirParent(final File file) throws IOException {
forceMkdir(getParentFile(Objects.requireNonNull(file, "file")));
}
/**
* Constructs a file from the set of name elements.
*
* @param directory the parent directory.
* @param names the name elements.
* @return the new file.
* @since 2.1
*/
public static File getFile(final File directory, final String... names) {
Objects.requireNonNull(directory, "directory");
Objects.requireNonNull(names, "names");
File file = directory;
for (final String name : names) {
file = new File(file, name);
}
return file;
}
/**
* Constructs a file from the set of name elements.
*
* @param names the name elements.
* @return the file.
* @since 2.1
*/
public static File getFile(final String... names) {
Objects.requireNonNull(names, "names");
File file = null;
for (final String name : names) {
if (file == null) {
file = new File(name);
} else {
file = new File(file, name);
}
}
return file;
}
/**
* Gets the parent of the given file. The given file may be null. Note that a file's parent may be null as well.
*
* @param file The file to query, may be null.
* @return The parent file or {@code null}. Note that a file's parent may be null as well.
*/
private static File getParentFile(final File file) {
return file == null ? null : file.getParentFile();
}
/**
* Returns a {@link File} representing the system temporary directory.
*
* @return the system temporary directory as a File
* @since 2.0
*/
public static File getTempDirectory() {
return new File(getTempDirectoryPath());
}
/**
* Returns the path to the system temporary directory.
*
* WARNING: this method relies on the Java system property 'java.io.tmpdir'
* which may or may not have a trailing file separator.
* This can affect code that uses String processing to manipulate pathnames rather
* than the standard libary methods in classes such as {@link java.io.File}
*
* @return the path to the system temporary directory as a String
* @since 2.0
*/
public static String getTempDirectoryPath() {
return System.getProperty("java.io.tmpdir");
}
/**
* Returns a {@link File} representing the user's home directory.
*
* @return the user's home directory.
* @since 2.0
*/
public static File getUserDirectory() {
return new File(getUserDirectoryPath());
}
/**
* Returns the path to the user's home directory.
*
* @return the path to the user's home directory.
* @since 2.0
*/
public static String getUserDirectoryPath() {
return System.getProperty("user.home");
}
/**
* Tests whether the specified {@link File} is a directory or not. Implemented as a
* null-safe delegate to {@link Files#isDirectory(Path path, LinkOption... options)}.
*
* @param file the path to the file.
* @param options options indicating how symbolic links are handled
* @return {@code true} if the file is a directory; {@code false} if
* the path is null, the file does not exist, is not a directory, or it cannot
* be determined if the file is a directory or not.
* @throws SecurityException In the case of the default provider, and a security manager is installed, the
* {@link SecurityManager#checkRead(String) checkRead} method is invoked to check read
* access to the directory.
* @since 2.9.0
*/
public static boolean isDirectory(final File file, final LinkOption... options) {
return file != null && Files.isDirectory(file.toPath(), options);
}
/**
* Tests whether the directory is empty.
*
* @param directory the directory to query.
* @return whether the directory is empty.
* @throws IOException if an I/O error occurs.
* @throws NotDirectoryException if the file could not otherwise be opened because it is not a directory
* (optional specific exception).
* @since 2.9.0
*/
public static boolean isEmptyDirectory(final File directory) throws IOException {
return PathUtils.isEmptyDirectory(directory.toPath());
}
/**
* Tests if the specified {@link File} is newer than the specified {@link ChronoLocalDate}
* at the end of day.
*
* Note: The input date is assumed to be in the system default time-zone with the time
* part set to the current time. To use a non-default time-zone use the method
* {@link #isFileNewer(File, ChronoLocalDateTime, ZoneId)
* isFileNewer(file, chronoLocalDate.atTime(LocalTime.now(zoneId)), zoneId)} where
* {@code zoneId} is a valid {@link ZoneId}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param chronoLocalDate the date reference.
* @return true if the {@link File} exists and has been modified after the given
* {@link ChronoLocalDate} at the current time.
* @throws UncheckedIOException if an I/O error occurs
* @throws NullPointerException if the file or local date is {@code null}.
* @since 2.8.0
*/
public static boolean isFileNewer(final File file, final ChronoLocalDate chronoLocalDate) {
return isFileNewer(file, chronoLocalDate, LocalTime.MAX);
}
/**
* Tests if the specified {@link File} is newer than the specified {@link ChronoLocalDate}
* at the specified time.
*
*
Note: The input date and time are assumed to be in the system default time-zone. To use a
* non-default time-zone use the method {@link #isFileNewer(File, ChronoLocalDateTime, ZoneId)
* isFileNewer(file, chronoLocalDate.atTime(localTime), zoneId)} where {@code zoneId} is a valid
* {@link ZoneId}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param chronoLocalDate the date reference.
* @param localTime the time reference.
* @return true if the {@link File} exists and has been modified after the given
* {@link ChronoLocalDate} at the given time.
* @throws UncheckedIOException if an I/O error occurs
* @throws NullPointerException if the file, local date or zone ID is {@code null}.
* @since 2.8.0
*/
public static boolean isFileNewer(final File file, final ChronoLocalDate chronoLocalDate, final LocalTime localTime) {
Objects.requireNonNull(chronoLocalDate, "chronoLocalDate");
Objects.requireNonNull(localTime, "localTime");
return isFileNewer(file, chronoLocalDate.atTime(localTime));
}
/**
* Tests if the specified {@link File} is newer than the specified {@link ChronoLocalDate} at the specified
* {@link OffsetTime}.
*
* @param file the {@link File} of which the modification date must be compared
* @param chronoLocalDate the date reference
* @param offsetTime the time reference
* @return true if the {@link File} exists and has been modified after the given {@link ChronoLocalDate} at the given
* {@link OffsetTime}.
* @throws UncheckedIOException if an I/O error occurs
* @throws NullPointerException if the file, local date or zone ID is {@code null}
* @since 2.12.0
*/
public static boolean isFileNewer(final File file, final ChronoLocalDate chronoLocalDate, final OffsetTime offsetTime) {
Objects.requireNonNull(chronoLocalDate, "chronoLocalDate");
Objects.requireNonNull(offsetTime, "offsetTime");
return isFileNewer(file, chronoLocalDate.atTime(offsetTime.toLocalTime()));
}
/**
* Tests if the specified {@link File} is newer than the specified {@link ChronoLocalDateTime}
* at the system-default time zone.
*
*
Note: The input date and time is assumed to be in the system default time-zone. To use a
* non-default time-zone use the method {@link #isFileNewer(File, ChronoLocalDateTime, ZoneId)
* isFileNewer(file, chronoLocalDateTime, zoneId)} where {@code zoneId} is a valid
* {@link ZoneId}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param chronoLocalDateTime the date reference.
* @return true if the {@link File} exists and has been modified after the given
* {@link ChronoLocalDateTime} at the system-default time zone.
* @throws UncheckedIOException if an I/O error occurs
* @throws NullPointerException if the file or local date time is {@code null}.
* @since 2.8.0
*/
public static boolean isFileNewer(final File file, final ChronoLocalDateTime chronoLocalDateTime) {
return isFileNewer(file, chronoLocalDateTime, ZoneId.systemDefault());
}
/**
* Tests if the specified {@link File} is newer than the specified {@link ChronoLocalDateTime}
* at the specified {@link ZoneId}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param chronoLocalDateTime the date reference.
* @param zoneId the time zone.
* @return true if the {@link File} exists and has been modified after the given
* {@link ChronoLocalDateTime} at the given {@link ZoneId}.
* @throws UncheckedIOException if an I/O error occurs
* @throws NullPointerException if the file, local date time or zone ID is {@code null}.
* @since 2.8.0
*/
public static boolean isFileNewer(final File file, final ChronoLocalDateTime chronoLocalDateTime, final ZoneId zoneId) {
Objects.requireNonNull(chronoLocalDateTime, "chronoLocalDateTime");
Objects.requireNonNull(zoneId, "zoneId");
return isFileNewer(file, chronoLocalDateTime.atZone(zoneId));
}
/**
* Tests if the specified {@link File} is newer than the specified {@link ChronoZonedDateTime}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param chronoZonedDateTime the date reference.
* @return true if the {@link File} exists and has been modified after the given
* {@link ChronoZonedDateTime}.
* @throws NullPointerException if the file or zoned date time is {@code null}.
* @throws UncheckedIOException if an I/O error occurs
* @since 2.8.0
*/
public static boolean isFileNewer(final File file, final ChronoZonedDateTime chronoZonedDateTime) {
Objects.requireNonNull(file, "file");
Objects.requireNonNull(chronoZonedDateTime, "chronoZonedDateTime");
return Uncheck.get(() -> PathUtils.isNewer(file.toPath(), chronoZonedDateTime));
}
/**
* Tests if the specified {@link File} is newer than the specified {@link Date}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param date the date reference.
* @return true if the {@link File} exists and has been modified
* after the given {@link Date}.
* @throws UncheckedIOException if an I/O error occurs
* @throws NullPointerException if the file or date is {@code null}.
*/
public static boolean isFileNewer(final File file, final Date date) {
Objects.requireNonNull(date, "date");
return isFileNewer(file, date.getTime());
}
/**
* Tests if the specified {@link File} is newer than the reference {@link File}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param reference the {@link File} of which the modification date is used.
* @return true if the {@link File} exists and has been modified more
* recently than the reference {@link File}.
* @throws NullPointerException if the file or reference file is {@code null}.
* @throws UncheckedIOException if the reference file doesn't exist.
*/
public static boolean isFileNewer(final File file, final File reference) {
return Uncheck.get(() -> PathUtils.isNewer(file.toPath(), reference.toPath()));
}
/**
* Tests if the specified {@link File} is newer than the specified {@link FileTime}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param fileTime the file time reference.
* @return true if the {@link File} exists and has been modified after the given {@link FileTime}.
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if the file or local date is {@code null}.
* @since 2.12.0
*/
public static boolean isFileNewer(final File file, final FileTime fileTime) throws IOException {
Objects.requireNonNull(file, "file");
return PathUtils.isNewer(file.toPath(), fileTime);
}
/**
* Tests if the specified {@link File} is newer than the specified {@link Instant}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param instant the date reference.
* @return true if the {@link File} exists and has been modified after the given {@link Instant}.
* @throws NullPointerException if the file or instant is {@code null}.
* @throws UncheckedIOException if an I/O error occurs
* @since 2.8.0
*/
public static boolean isFileNewer(final File file, final Instant instant) {
Objects.requireNonNull(instant, "instant");
return Uncheck.get(() -> PathUtils.isNewer(file.toPath(), instant));
}
/**
* Tests if the specified {@link File} is newer than the specified time reference.
*
* @param file the {@link File} of which the modification date must be compared.
* @param timeMillis the time reference measured in milliseconds since the
* epoch (00:00:00 GMT, January 1, 1970).
* @return true if the {@link File} exists and has been modified after the given time reference.
* @throws UncheckedIOException if an I/O error occurs
* @throws NullPointerException if the file is {@code null}.
*/
public static boolean isFileNewer(final File file, final long timeMillis) {
Objects.requireNonNull(file, "file");
return Uncheck.get(() -> PathUtils.isNewer(file.toPath(), timeMillis));
}
/**
* Tests if the specified {@link File} is newer than the specified {@link OffsetDateTime}.
*
* @param file the {@link File} of which the modification date must be compared
* @param offsetDateTime the date reference
* @return true if the {@link File} exists and has been modified before the given {@link OffsetDateTime}.
* @throws UncheckedIOException if an I/O error occurs
* @throws NullPointerException if the file or zoned date time is {@code null}
* @since 2.12.0
*/
public static boolean isFileNewer(final File file, final OffsetDateTime offsetDateTime) {
Objects.requireNonNull(offsetDateTime, "offsetDateTime");
return isFileNewer(file, offsetDateTime.toInstant());
}
/**
* Tests if the specified {@link File} is older than the specified {@link ChronoLocalDate}
* at the end of day.
*
*
Note: The input date is assumed to be in the system default time-zone with the time
* part set to the current time. To use a non-default time-zone use the method
* {@link #isFileOlder(File, ChronoLocalDateTime, ZoneId)
* isFileOlder(file, chronoLocalDate.atTime(LocalTime.now(zoneId)), zoneId)} where
* {@code zoneId} is a valid {@link ZoneId}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param chronoLocalDate the date reference.
* @return true if the {@link File} exists and has been modified before the given
* {@link ChronoLocalDate} at the current time.
* @throws NullPointerException if the file or local date is {@code null}.
* @throws UncheckedIOException if an I/O error occurs
* @see ZoneId#systemDefault()
* @see LocalTime#now()
* @since 2.8.0
*/
public static boolean isFileOlder(final File file, final ChronoLocalDate chronoLocalDate) {
return isFileOlder(file, chronoLocalDate, LocalTime.MAX);
}
/**
* Tests if the specified {@link File} is older than the specified {@link ChronoLocalDate}
* at the specified {@link LocalTime}.
*
*
Note: The input date and time are assumed to be in the system default time-zone. To use a
* non-default time-zone use the method {@link #isFileOlder(File, ChronoLocalDateTime, ZoneId)
* isFileOlder(file, chronoLocalDate.atTime(localTime), zoneId)} where {@code zoneId} is a valid
* {@link ZoneId}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param chronoLocalDate the date reference.
* @param localTime the time reference.
* @return true if the {@link File} exists and has been modified before the
* given {@link ChronoLocalDate} at the specified time.
* @throws UncheckedIOException if an I/O error occurs
* @throws NullPointerException if the file, local date or local time is {@code null}.
* @see ZoneId#systemDefault()
* @since 2.8.0
*/
public static boolean isFileOlder(final File file, final ChronoLocalDate chronoLocalDate, final LocalTime localTime) {
Objects.requireNonNull(chronoLocalDate, "chronoLocalDate");
Objects.requireNonNull(localTime, "localTime");
return isFileOlder(file, chronoLocalDate.atTime(localTime));
}
/**
* Tests if the specified {@link File} is older than the specified {@link ChronoLocalDate} at the specified
* {@link OffsetTime}.
*
* @param file the {@link File} of which the modification date must be compared
* @param chronoLocalDate the date reference
* @param offsetTime the time reference
* @return true if the {@link File} exists and has been modified after the given {@link ChronoLocalDate} at the given
* {@link OffsetTime}.
* @throws NullPointerException if the file, local date or zone ID is {@code null}
* @throws UncheckedIOException if an I/O error occurs
* @since 2.12.0
*/
public static boolean isFileOlder(final File file, final ChronoLocalDate chronoLocalDate, final OffsetTime offsetTime) {
Objects.requireNonNull(chronoLocalDate, "chronoLocalDate");
Objects.requireNonNull(offsetTime, "offsetTime");
return isFileOlder(file, chronoLocalDate.atTime(offsetTime.toLocalTime()));
}
/**
* Tests if the specified {@link File} is older than the specified {@link ChronoLocalDateTime}
* at the system-default time zone.
*
*
Note: The input date and time is assumed to be in the system default time-zone. To use a
* non-default time-zone use the method {@link #isFileOlder(File, ChronoLocalDateTime, ZoneId)
* isFileOlder(file, chronoLocalDateTime, zoneId)} where {@code zoneId} is a valid
* {@link ZoneId}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param chronoLocalDateTime the date reference.
* @return true if the {@link File} exists and has been modified before the given
* {@link ChronoLocalDateTime} at the system-default time zone.
* @throws NullPointerException if the file or local date time is {@code null}.
* @throws UncheckedIOException if an I/O error occurs
* @see ZoneId#systemDefault()
* @since 2.8.0
*/
public static boolean isFileOlder(final File file, final ChronoLocalDateTime chronoLocalDateTime) {
return isFileOlder(file, chronoLocalDateTime, ZoneId.systemDefault());
}
/**
* Tests if the specified {@link File} is older than the specified {@link ChronoLocalDateTime}
* at the specified {@link ZoneId}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param chronoLocalDateTime the date reference.
* @param zoneId the time zone.
* @return true if the {@link File} exists and has been modified before the given
* {@link ChronoLocalDateTime} at the given {@link ZoneId}.
* @throws NullPointerException if the file, local date time or zone ID is {@code null}.
* @throws UncheckedIOException if an I/O error occurs
* @since 2.8.0
*/
public static boolean isFileOlder(final File file, final ChronoLocalDateTime chronoLocalDateTime, final ZoneId zoneId) {
Objects.requireNonNull(chronoLocalDateTime, "chronoLocalDateTime");
Objects.requireNonNull(zoneId, "zoneId");
return isFileOlder(file, chronoLocalDateTime.atZone(zoneId));
}
/**
* Tests if the specified {@link File} is older than the specified {@link ChronoZonedDateTime}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param chronoZonedDateTime the date reference.
* @return true if the {@link File} exists and has been modified before the given
* {@link ChronoZonedDateTime}.
* @throws NullPointerException if the file or zoned date time is {@code null}.
* @throws UncheckedIOException if an I/O error occurs
* @since 2.8.0
*/
public static boolean isFileOlder(final File file, final ChronoZonedDateTime chronoZonedDateTime) {
Objects.requireNonNull(chronoZonedDateTime, "chronoZonedDateTime");
return isFileOlder(file, chronoZonedDateTime.toInstant());
}
/**
* Tests if the specified {@link File} is older than the specified {@link Date}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param date the date reference.
* @return true if the {@link File} exists and has been modified before the given {@link Date}.
* @throws NullPointerException if the file or date is {@code null}.
* @throws UncheckedIOException if an I/O error occurs
*/
public static boolean isFileOlder(final File file, final Date date) {
Objects.requireNonNull(date, "date");
return isFileOlder(file, date.getTime());
}
/**
* Tests if the specified {@link File} is older than the reference {@link File}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param reference the {@link File} of which the modification date is used.
* @return true if the {@link File} exists and has been modified before the reference {@link File}.
* @throws NullPointerException if the file or reference file is {@code null}.
* @throws FileNotFoundException if the reference file doesn't exist.
* @throws UncheckedIOException if an I/O error occurs
*/
public static boolean isFileOlder(final File file, final File reference) throws FileNotFoundException {
return Uncheck.get(() -> PathUtils.isOlder(file.toPath(), reference.toPath()));
}
/**
* Tests if the specified {@link File} is older than the specified {@link FileTime}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param fileTime the file time reference.
* @return true if the {@link File} exists and has been modified before the given {@link FileTime}.
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if the file or local date is {@code null}.
* @since 2.12.0
*/
public static boolean isFileOlder(final File file, final FileTime fileTime) throws IOException {
Objects.requireNonNull(file, "file");
return PathUtils.isOlder(file.toPath(), fileTime);
}
/**
* Tests if the specified {@link File} is older than the specified {@link Instant}.
*
* @param file the {@link File} of which the modification date must be compared.
* @param instant the date reference.
* @return true if the {@link File} exists and has been modified before the given {@link Instant}.
* @throws NullPointerException if the file or instant is {@code null}.
* @since 2.8.0
*/
public static boolean isFileOlder(final File file, final Instant instant) {
Objects.requireNonNull(instant, "instant");
return Uncheck.get(() -> PathUtils.isOlder(file.toPath(), instant));
}
/**
* Tests if the specified {@link File} is older than the specified time reference.
*
* @param file the {@link File} of which the modification date must be compared.
* @param timeMillis the time reference measured in milliseconds since the
* epoch (00:00:00 GMT, January 1, 1970).
* @return true if the {@link File} exists and has been modified before the given time reference.
* @throws NullPointerException if the file is {@code null}.
* @throws UncheckedIOException if an I/O error occurs
*/
public static boolean isFileOlder(final File file, final long timeMillis) {
Objects.requireNonNull(file, "file");
return Uncheck.get(() -> PathUtils.isOlder(file.toPath(), timeMillis));
}
/**
* Tests if the specified {@link File} is older than the specified {@link OffsetDateTime}.
*
* @param file the {@link File} of which the modification date must be compared
* @param offsetDateTime the date reference
* @return true if the {@link File} exists and has been modified before the given {@link OffsetDateTime}.
* @throws NullPointerException if the file or zoned date time is {@code null}
* @since 2.12.0
*/
public static boolean isFileOlder(final File file, final OffsetDateTime offsetDateTime) {
Objects.requireNonNull(offsetDateTime, "offsetDateTime");
return isFileOlder(file, offsetDateTime.toInstant());
}
/**
* Tests whether the specified {@link File} is a regular file or not. Implemented as a
* null-safe delegate to {@link Files#isRegularFile(Path path, LinkOption... options)}.
*
* @param file the path to the file.
* @param options options indicating how symbolic links are handled
* @return {@code true} if the file is a regular file; {@code false} if
* the path is null, the file does not exist, is not a regular file, or it cannot
* be determined if the file is a regular file or not.
* @throws SecurityException In the case of the default provider, and a security manager is installed, the
* {@link SecurityManager#checkRead(String) checkRead} method is invoked to check read
* access to the directory.
* @since 2.9.0
*/
public static boolean isRegularFile(final File file, final LinkOption... options) {
return file != null && Files.isRegularFile(file.toPath(), options);
}
/**
* Tests whether the specified file is a symbolic link rather than an actual file.
*
* This method delegates to {@link Files#isSymbolicLink(Path path)}
*
*
* @param file the file to test.
* @return true if the file is a symbolic link, see {@link Files#isSymbolicLink(Path path)}.
* @since 2.0
* @see Files#isSymbolicLink(Path)
*/
public static boolean isSymlink(final File file) {
return file != null && Files.isSymbolicLink(file.toPath());
}
/**
* Iterates over the files in given directory (and optionally
* its subdirectories).
*
* The resulting iterator MUST be consumed in its entirety in order to close its underlying stream.
*
*
* All files found are filtered by an IOFileFilter.
*
*
* @param directory the directory to search in
* @param fileFilter filter to apply when finding files.
* @param dirFilter optional filter to apply when finding subdirectories.
* If this parameter is {@code null}, subdirectories will not be included in the
* search. Use TrueFileFilter.INSTANCE to match all directories.
* @return an iterator of {@link File} for the matching files
* @see org.apache.commons.io.filefilter.FileFilterUtils
* @see org.apache.commons.io.filefilter.NameFileFilter
* @since 1.2
*/
public static Iterator iterateFiles(final File directory, final IOFileFilter fileFilter, final IOFileFilter dirFilter) {
return listFiles(directory, fileFilter, dirFilter).iterator();
}
/**
* Iterates over the files in a given directory (and optionally
* its subdirectories) which match an array of extensions.
*
* The resulting iterator MUST be consumed in its entirety in order to close its underlying stream.
*
*
* @param directory the directory to search in
* @param extensions an array of extensions, for example, {"java","xml"}. If this
* parameter is {@code null}, all files are returned.
* @param recursive if true all subdirectories are searched as well
* @return an iterator of {@link File} with the matching files
* @since 1.2
*/
public static Iterator iterateFiles(final File directory, final String[] extensions, final boolean recursive) {
return StreamIterator.iterator(Uncheck.get(() -> streamFiles(directory, recursive, extensions)));
}
/**
* Iterates over the files in given directory (and optionally
* its subdirectories).
*
* The resulting iterator MUST be consumed in its entirety in order to close its underlying stream.
*
*
* All files found are filtered by an IOFileFilter.
*
*
* The resulting iterator includes the subdirectories themselves.
*
*
* @param directory the directory to search in
* @param fileFilter filter to apply when finding files.
* @param dirFilter optional filter to apply when finding subdirectories.
* If this parameter is {@code null}, subdirectories will not be included in the
* search. Use TrueFileFilter.INSTANCE to match all directories.
* @return an iterator of {@link File} for the matching files
* @see org.apache.commons.io.filefilter.FileFilterUtils
* @see org.apache.commons.io.filefilter.NameFileFilter
* @since 2.2
*/
public static Iterator iterateFilesAndDirs(final File directory, final IOFileFilter fileFilter, final IOFileFilter dirFilter) {
return listFilesAndDirs(directory, fileFilter, dirFilter).iterator();
}
/**
* Returns the last modification time in milliseconds via
* {@link java.nio.file.Files#getLastModifiedTime(Path, LinkOption...)}.
*
* For the best precision, use {@link #lastModifiedFileTime(File)}.
*
*
* Use this method to avoid issues with {@link File#lastModified()} like
* JDK-8177809 where {@link File#lastModified()} is
* losing milliseconds (always ends in 000). This bug exists in OpenJDK 8 and 9, and is fixed in 10.
*
*
* @param file The File to query.
* @return See {@link java.nio.file.attribute.FileTime#toMillis()}.
* @throws IOException if an I/O error occurs.
* @since 2.9.0
*/
public static long lastModified(final File file) throws IOException {
// https://bugs.openjdk.java.net/browse/JDK-8177809
// File.lastModified() is losing milliseconds (always ends in 000)
// This bug is in OpenJDK 8 and 9, and fixed in 10.
return lastModifiedFileTime(file).toMillis();
}
/**
* Returns the last modification {@link FileTime} via
* {@link java.nio.file.Files#getLastModifiedTime(Path, LinkOption...)}.
*
* Use this method to avoid issues with {@link File#lastModified()} like
* JDK-8177809 where {@link File#lastModified()} is
* losing milliseconds (always ends in 000). This bug exists in OpenJDK 8 and 9, and is fixed in 10.
*
*
* @param file The File to query.
* @return See {@link java.nio.file.Files#getLastModifiedTime(Path, LinkOption...)}.
* @throws IOException if an I/O error occurs.
* @since 2.12.0
*/
public static FileTime lastModifiedFileTime(final File file) throws IOException {
// https://bugs.openjdk.java.net/browse/JDK-8177809
// File.lastModified() is losing milliseconds (always ends in 000)
// This bug is in OpenJDK 8 and 9, and fixed in 10.
return Files.getLastModifiedTime(Objects.requireNonNull(file.toPath(), "file"));
}
/**
* Returns the last modification time in milliseconds via
* {@link java.nio.file.Files#getLastModifiedTime(Path, LinkOption...)}.
*
* For the best precision, use {@link #lastModifiedFileTime(File)}.
*
*
* Use this method to avoid issues with {@link File#lastModified()} like
* JDK-8177809 where {@link File#lastModified()} is
* losing milliseconds (always ends in 000). This bug exists in OpenJDK 8 and 9, and is fixed in 10.
*
*
* @param file The File to query.
* @return See {@link java.nio.file.attribute.FileTime#toMillis()}.
* @throws UncheckedIOException if an I/O error occurs.
* @since 2.9.0
*/
public static long lastModifiedUnchecked(final File file) {
// https://bugs.openjdk.java.net/browse/JDK-8177809
// File.lastModified() is losing milliseconds (always ends in 000)
// This bug is in OpenJDK 8 and 9, and fixed in 10.
return Uncheck.apply(FileUtils::lastModified, file);
}
/**
* Returns an Iterator for the lines in a {@link File} using the default encoding for the VM.
*
* @param file the file to open for input, must not be {@code null}
* @return an Iterator of the lines in the file, never {@code null}
* @throws NullPointerException if file is {@code null}.
* @throws FileNotFoundException if the file does not exist, is a directory rather than a regular file, or for some
* other reason cannot be opened for reading.
* @throws IOException if an I/O error occurs.
* @see #lineIterator(File, String)
* @since 1.3
*/
public static LineIterator lineIterator(final File file) throws IOException {
return lineIterator(file, null);
}
/**
* Returns an Iterator for the lines in a {@link File}.
*
* This method opens an {@link InputStream} for the file.
* When you have finished with the iterator you should close the stream
* to free internal resources. This can be done by using a try-with-resources block or calling the
* {@link LineIterator#close()} method.
*
*
* The recommended usage pattern is:
*
*
* LineIterator it = FileUtils.lineIterator(file, StandardCharsets.UTF_8.name());
* try {
* while (it.hasNext()) {
* String line = it.nextLine();
* /// do something with line
* }
* } finally {
* LineIterator.closeQuietly(iterator);
* }
*
*
* If an exception occurs during the creation of the iterator, the
* underlying stream is closed.
*
*
* @param file the file to open for input, must not be {@code null}
* @param charsetName the name of the requested charset, {@code null} means platform default
* @return a LineIterator for lines in the file, never {@code null}; MUST be closed by the caller.
* @throws NullPointerException if file is {@code null}.
* @throws FileNotFoundException if the file does not exist, is a directory rather than a regular file, or for some
* other reason cannot be opened for reading.
* @throws IOException if an I/O error occurs.
* @since 1.2
*/
@SuppressWarnings("resource") // Caller closes the result LineIterator.
public static LineIterator lineIterator(final File file, final String charsetName) throws IOException {
InputStream inputStream = null;
try {
inputStream = Files.newInputStream(file.toPath());
return IOUtils.lineIterator(inputStream, charsetName);
} catch (final IOException | RuntimeException ex) {
IOUtils.closeQuietly(inputStream, ex::addSuppressed);
throw ex;
}
}
private static AccumulatorPathVisitor listAccumulate(final File directory, final IOFileFilter fileFilter, final IOFileFilter dirFilter,
final FileVisitOption... options) throws IOException {
final boolean isDirFilterSet = dirFilter != null;
final FileEqualsFileFilter rootDirFilter = new FileEqualsFileFilter(directory);
final PathFilter dirPathFilter = isDirFilterSet ? rootDirFilter.or(dirFilter) : rootDirFilter;
final AccumulatorPathVisitor visitor = new AccumulatorPathVisitor(Counters.noopPathCounters(), fileFilter, dirPathFilter,
(p, e) -> FileVisitResult.CONTINUE);
final Set optionSet = new HashSet<>();
if (options != null) {
Collections.addAll(optionSet, options);
}
Files.walkFileTree(directory.toPath(), optionSet, toMaxDepth(isDirFilterSet), visitor);
return visitor;
}
/**
* Lists files in a directory, asserting that the supplied directory exists and is a directory.
*
* @param directory The directory to list
* @param fileFilter Optional file filter, may be null.
* @return The files in the directory, never {@code null}.
* @throws NullPointerException if directory is {@code null}.
* @throws IllegalArgumentException if {@link directory} exists but is not a directory
* @throws IOException if an I/O error occurs.
*/
private static File[] listFiles(final File directory, final FileFilter fileFilter) throws IOException {
requireDirectoryExists(directory, "directory");
final File[] files = fileFilter == null ? directory.listFiles() : directory.listFiles(fileFilter);
if (files == null) {
// null if the directory does not denote a directory, or if an I/O error occurs.
throw new IOException("Unknown I/O error listing contents of directory: " + directory);
}
return files;
}
/**
* Finds files within a given directory (and optionally its
* subdirectories). All files found are filtered by an IOFileFilter.
*
* If your search should recurse into subdirectories you can pass in
* an IOFileFilter for directories. You don't need to bind a
* DirectoryFileFilter (via logical AND) to this filter. This method does
* that for you.
*
*
* An example: If you want to search through all directories called
* "temp" you pass in {@code FileFilterUtils.NameFileFilter("temp")}
*
*
* Another common usage of this method is find files in a directory
* tree but ignoring the directories generated CVS. You can simply pass
* in {@code FileFilterUtils.makeCVSAware(null)}.
*
*
* @param directory the directory to search in
* @param fileFilter filter to apply when finding files. Must not be {@code null},
* use {@link TrueFileFilter#INSTANCE} to match all files in selected directories.
* @param dirFilter optional filter to apply when finding subdirectories.
* If this parameter is {@code null}, subdirectories will not be included in the
* search. Use {@link TrueFileFilter#INSTANCE} to match all directories.
* @return a collection of {@link File} with the matching files
* @see org.apache.commons.io.filefilter.FileFilterUtils
* @see org.apache.commons.io.filefilter.NameFileFilter
*/
public static Collection listFiles(final File directory, final IOFileFilter fileFilter, final IOFileFilter dirFilter) {
final AccumulatorPathVisitor visitor = Uncheck
.apply(d -> listAccumulate(d, FileFileFilter.INSTANCE.and(fileFilter), dirFilter, FileVisitOption.FOLLOW_LINKS), directory);
return toList(visitor.getFileList().stream().map(Path::toFile));
}
/**
* Lists files within a given directory (and optionally its subdirectories)
* which match an array of extensions.
*
* @param directory the directory to search in
* @param extensions an array of extensions, for example, {"java","xml"}. If this
* parameter is {@code null}, all files are returned.
* @param recursive if true all subdirectories are searched as well
* @return a collection of {@link File} with the matching files
*/
public static Collection listFiles(final File directory, final String[] extensions, final boolean recursive) {
try (Stream fileStream = Uncheck.get(() -> streamFiles(directory, recursive, extensions))) {
return toList(fileStream);
}
}
/**
* Finds files within a given directory (and optionally its
* subdirectories). All files found are filtered by an IOFileFilter.
*
* The resulting collection includes the starting directory and
* any subdirectories that match the directory filter.
*
*
* @param directory the directory to search in
* @param fileFilter filter to apply when finding files.
* @param dirFilter optional filter to apply when finding subdirectories.
* If this parameter is {@code null}, subdirectories will not be included in the
* search. Use TrueFileFilter.INSTANCE to match all directories.
* @return a collection of {@link File} with the matching files
* @see org.apache.commons.io.FileUtils#listFiles
* @see org.apache.commons.io.filefilter.FileFilterUtils
* @see org.apache.commons.io.filefilter.NameFileFilter
* @since 2.2
*/
public static Collection listFilesAndDirs(final File directory, final IOFileFilter fileFilter, final IOFileFilter dirFilter) {
final AccumulatorPathVisitor visitor = Uncheck.apply(d -> listAccumulate(d, fileFilter, dirFilter, FileVisitOption.FOLLOW_LINKS),
directory);
final List list = visitor.getFileList();
list.addAll(visitor.getDirList());
return toList(list.stream().map(Path::toFile));
}
/**
* Calls {@link File#mkdirs()} and throws an {@link IOException} on failure.
*
* Creates all directories for a File object, including any necessary but non-existent parent directories. If the {@code directory} already exists or is
* null, nothing happens.
*
*
* @param directory the receiver for {@code mkdirs()}. If the {@code directory} already exists or is null, nothing happens.
* @return the given directory.
* @throws IOException if the directory was not created along with all its parent directories.
* @throws IOException if the given file object is not a directory.
* @throws SecurityException See {@link File#mkdirs()}.
* @see File#mkdirs()
*/
private static File mkdirs(final File directory) throws IOException {
if (directory != null && !directory.mkdirs() && !directory.isDirectory()) {
throw new IOException("Cannot create directory '" + directory + "'.");
}
return directory;
}
/**
* Moves a directory.
*
* When the destination directory is on another file system, do a "copy and delete".
*
*
* @param srcDir the directory to be moved.
* @param destDir the destination directory.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IllegalArgumentException if {@code srcDir} exists but is not a directory
* @throws FileNotFoundException if the source does not exist.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @since 1.4
*/
public static void moveDirectory(final File srcDir, final File destDir) throws IOException {
Objects.requireNonNull(destDir, "destination");
requireDirectoryExists(srcDir, "srcDir");
requireAbsent(destDir, "destDir");
if (!srcDir.renameTo(destDir)) {
if (destDir.getCanonicalPath().startsWith(srcDir.getCanonicalPath() + File.separator)) {
throw new IOException("Cannot move directory: " + srcDir + " to a subdirectory of itself: " + destDir);
}
copyDirectory(srcDir, destDir);
deleteDirectory(srcDir);
if (srcDir.exists()) {
throw new IOException("Failed to delete original directory '" + srcDir +
"' after copy to '" + destDir + "'");
}
}
}
/**
* Moves a directory to another directory.
*
* If {@code createDestDir} is true, creates all destination parent directories, including any necessary but non-existent parent directories.
*
*
* @param source the directory to be moved.
* @param destDir the destination file.
* @param createDestDir If {@code true} create the destination directory, otherwise if {@code false} throw an
* IOException.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws IllegalArgumentException if the source or destination is invalid.
* @throws FileNotFoundException if the source does not exist.
* @throws IOException if the directory was not created along with all its parent directories, if enabled.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @throws SecurityException See {@link File#mkdirs()}.
* @since 1.4
*/
public static void moveDirectoryToDirectory(final File source, final File destDir, final boolean createDestDir) throws IOException {
validateMoveParameters(source, destDir);
if (!destDir.isDirectory()) {
if (destDir.exists()) {
throw new IOException("Destination '" + destDir + "' is not a directory");
}
if (!createDestDir) {
throw new FileNotFoundException("Destination directory '" + destDir + "' does not exist [createDestDir=" + false + "]");
}
mkdirs(destDir);
}
moveDirectory(source, new File(destDir, source.getName()));
}
/**
* Moves a file preserving attributes.
*
* Shorthand for {@code moveFile(srcFile, destFile, StandardCopyOption.COPY_ATTRIBUTES)}.
*
*
* When the destination file is on another file system, do a "copy and delete".
*
*
* @param srcFile the file to be moved.
* @param destFile the destination file.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws FileExistsException if the destination file exists.
* @throws FileNotFoundException if the source file does not exist.
* @throws IllegalArgumentException if {@code srcFile} is a directory
* @throws IOException if an error occurs.
* @since 1.4
*/
public static void moveFile(final File srcFile, final File destFile) throws IOException {
moveFile(srcFile, destFile, StandardCopyOption.COPY_ATTRIBUTES);
}
/**
* Moves a file.
*
* When the destination file is on another file system, do a "copy and delete".
*
*
* @param srcFile the file to be moved.
* @param destFile the destination file.
* @param copyOptions Copy options.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws FileExistsException if the destination file exists.
* @throws FileNotFoundException if the source file does not exist.
* @throws IllegalArgumentException if {@code srcFile} is a directory
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @since 2.9.0
*/
public static void moveFile(final File srcFile, final File destFile, final CopyOption... copyOptions) throws IOException {
Objects.requireNonNull(destFile, "destination");
checkFileExists(srcFile, "srcFile");
requireAbsent(destFile, "destFile");
final boolean rename = srcFile.renameTo(destFile);
if (!rename) {
// Don't interfere with file date on move, handled by StandardCopyOption.COPY_ATTRIBUTES
copyFile(srcFile, destFile, false, copyOptions);
if (!srcFile.delete()) {
FileUtils.deleteQuietly(destFile);
throw new IOException("Failed to delete original file '" + srcFile + "' after copy to '" + destFile + "'");
}
}
}
/**
* Moves a file into a directory.
*
* If {@code createDestDir} is true, creates all destination parent directories, including any necessary but non-existent parent directories.
*
*
* @param srcFile the file to be moved.
* @param destDir the directory to move the file into
* @param createDestDir if {@code true} create the destination directory. If {@code false} throw an
* IOException if the destination directory does not already exist.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws FileExistsException if the destination file exists.
* @throws FileNotFoundException if the source file does not exist.
* @throws IOException if source or destination is invalid.
* @throws IOException if the directory was not created along with all its parent directories, if enabled.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @throws SecurityException See {@link File#mkdirs()}.
* @throws IllegalArgumentException if {@code destDir} exists but is not a directory
* @since 1.4
*/
public static void moveFileToDirectory(final File srcFile, final File destDir, final boolean createDestDir) throws IOException {
validateMoveParameters(srcFile, destDir);
if (!destDir.exists() && createDestDir) {
mkdirs(destDir);
}
requireDirectoryExists(destDir, "destDir");
moveFile(srcFile, new File(destDir, srcFile.getName()));
}
/**
* Moves a file or directory into a destination directory.
*
* If {@code createDestDir} is true, creates all destination parent directories, including any necessary but non-existent parent directories.
*
*
* When the destination is on another file system, do a "copy and delete".
*
*
* @param src the file or directory to be moved.
* @param destDir the destination directory.
* @param createDestDir if {@code true} create the destination directory. If {@code false} throw an
* IOException if the destination directory does not already exist.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws FileExistsException if the directory or file exists in the destination directory.
* @throws FileNotFoundException if the source file does not exist.
* @throws IOException if source or destination is invalid.
* @throws IOException if an error occurs or setting the last-modified time didn't succeed.
* @since 1.4
*/
public static void moveToDirectory(final File src, final File destDir, final boolean createDestDir) throws IOException {
validateMoveParameters(src, destDir);
if (src.isDirectory()) {
moveDirectoryToDirectory(src, destDir, createDestDir);
} else {
moveFileToDirectory(src, destDir, createDestDir);
}
}
/**
* Creates a new OutputStream by opening or creating a file, returning an output stream that may be used to write bytes
* to the file.
*
* @param append Whether or not to append.
* @param file the File.
* @return a new OutputStream.
* @throws IOException if an I/O error occurs.
* @see PathUtils#newOutputStream(Path, boolean)
* @since 2.12.0
*/
public static OutputStream newOutputStream(final File file, final boolean append) throws IOException {
return PathUtils.newOutputStream(Objects.requireNonNull(file, "file").toPath(), append);
}
/**
* Opens a {@link FileInputStream} for the specified file, providing better error messages than simply calling
* {@code new FileInputStream(file)}.
*
* At the end of the method either the stream will be successfully opened, or an exception will have been thrown.
*
*
* An exception is thrown if the file does not exist. An exception is thrown if the file object exists but is a
* directory. An exception is thrown if the file exists but cannot be read.
*
*
* @param file the file to open for input, must not be {@code null}
* @return a new {@link FileInputStream} for the specified file
* @throws NullPointerException if file is {@code null}.
* @throws FileNotFoundException if the file does not exist, is a directory rather than a regular file, or for some
* other reason cannot be opened for reading.
* @throws IOException See FileNotFoundException above, FileNotFoundException is a subclass of IOException.
* @since 1.3
*/
public static FileInputStream openInputStream(final File file) throws IOException {
Objects.requireNonNull(file, "file");
return new FileInputStream(file);
}
/**
* Opens a {@link FileOutputStream} for the specified file, checking and
* creating the parent directory if it does not exist.
*
* At the end of the method either the stream will be successfully opened,
* or an exception will have been thrown.
*
*
* The parent directory will be created if it does not exist.
* The file will be created if it does not exist.
* An exception is thrown if the file object exists but is a directory.
* An exception is thrown if the file exists but cannot be written to.
* An exception is thrown if the parent directory cannot be created.
*
*
* @param file the file to open for output, must not be {@code null}
* @return a new {@link FileOutputStream} for the specified file
* @throws NullPointerException if the file object is {@code null}.
* @throws IllegalArgumentException if the file object is a directory
* @throws IllegalArgumentException if the file is not writable.
* @throws IOException if the directories could not be created.
* @since 1.3
*/
public static FileOutputStream openOutputStream(final File file) throws IOException {
return openOutputStream(file, false);
}
/**
* Opens a {@link FileOutputStream} for the specified file, checking and
* creating the parent directory if it does not exist.
*
* At the end of the method either the stream will be successfully opened,
* or an exception will have been thrown.
*
*
* The parent directory will be created if it does not exist.
* The file will be created if it does not exist.
* An exception is thrown if the file object exists but is a directory.
* An exception is thrown if the file exists but cannot be written to.
* An exception is thrown if the parent directory cannot be created.
*
*
* @param file the file to open for output, must not be {@code null}
* @param append if {@code true}, then bytes will be added to the
* end of the file rather than overwriting
* @return a new {@link FileOutputStream} for the specified file
* @throws NullPointerException if the file object is {@code null}.
* @throws IllegalArgumentException if the file object is a directory
* @throws IOException if the directories could not be created, or the file is not writable
* @since 2.1
*/
public static FileOutputStream openOutputStream(final File file, final boolean append) throws IOException {
Objects.requireNonNull(file, "file");
if (file.exists()) {
checkIsFile(file, "file");
} else {
createParentDirectories(file);
}
return new FileOutputStream(file, append);
}
/**
* Reads the contents of a file into a byte array.
* The file is always closed.
*
* @param file the file to read, must not be {@code null}
* @return the file contents, never {@code null}
* @throws NullPointerException if file is {@code null}.
* @throws IOException if an I/O error occurs, including when the file does not exist, is a directory rather than a
* regular file, or for some other reason why the file cannot be opened for reading.
* @since 1.1
*/
public static byte[] readFileToByteArray(final File file) throws IOException {
Objects.requireNonNull(file, "file");
return Files.readAllBytes(file.toPath());
}
/**
* Reads the contents of a file into a String using the default encoding for the VM.
* The file is always closed.
*
* @param file the file to read, must not be {@code null}
* @return the file contents, never {@code null}
* @throws NullPointerException if file is {@code null}.
* @throws IOException if an I/O error occurs, including when the file does not exist, is a directory rather than a
* regular file, or for some other reason why the file cannot be opened for reading.
* @since 1.3.1
* @deprecated Use {@link #readFileToString(File, Charset)} instead (and specify the appropriate encoding)
*/
@Deprecated
public static String readFileToString(final File file) throws IOException {
return readFileToString(file, Charset.defaultCharset());
}
/**
* Reads the contents of a file into a String.
* The file is always closed.
*
* @param file the file to read, must not be {@code null}
* @param charsetName the name of the requested charset, {@code null} means platform default
* @return the file contents, never {@code null}
* @throws NullPointerException if file is {@code null}.
* @throws IOException if an I/O error occurs, including when the file does not exist, is a directory rather than a
* regular file, or for some other reason why the file cannot be opened for reading.
* @since 2.3
*/
public static String readFileToString(final File file, final Charset charsetName) throws IOException {
return IOUtils.toString(() -> Files.newInputStream(file.toPath()), Charsets.toCharset(charsetName));
}
/**
* Reads the contents of a file into a String. The file is always closed.
*
* @param file the file to read, must not be {@code null}
* @param charsetName the name of the requested charset, {@code null} means platform default
* @return the file contents, never {@code null}
* @throws NullPointerException if file is {@code null}.
* @throws IOException if an I/O error occurs, including when the file does not exist, is a directory rather than a
* regular file, or for some other reason why the file cannot be opened for reading.
* @throws java.nio.charset.UnsupportedCharsetException if the named charset is unavailable.
* @since 2.3
*/
public static String readFileToString(final File file, final String charsetName) throws IOException {
return readFileToString(file, Charsets.toCharset(charsetName));
}
/**
* Reads the contents of a file line by line to a List of Strings using the default encoding for the VM.
* The file is always closed.
*
* @param file the file to read, must not be {@code null}
* @return the list of Strings representing each line in the file, never {@code null}
* @throws NullPointerException if file is {@code null}.
* @throws IOException if an I/O error occurs, including when the file does not exist, is a directory rather than a
* regular file, or for some other reason why the file cannot be opened for reading.
* @since 1.3
* @deprecated Use {@link #readLines(File, Charset)} instead (and specify the appropriate encoding)
*/
@Deprecated
public static List readLines(final File file) throws IOException {
return readLines(file, Charset.defaultCharset());
}
/**
* Reads the contents of a file line by line to a List of Strings.
* The file is always closed.
*
* @param file the file to read, must not be {@code null}
* @param charset the charset to use, {@code null} means platform default
* @return the list of Strings representing each line in the file, never {@code null}
* @throws NullPointerException if file is {@code null}.
* @throws IOException if an I/O error occurs, including when the file does not exist, is a directory rather than a
* regular file, or for some other reason why the file cannot be opened for reading.
* @since 2.3
*/
public static List readLines(final File file, final Charset charset) throws IOException {
return Files.readAllLines(file.toPath(), charset);
}
/**
* Reads the contents of a file line by line to a List of Strings. The file is always closed.
*
* @param file the file to read, must not be {@code null}
* @param charsetName the name of the requested charset, {@code null} means platform default
* @return the list of Strings representing each line in the file, never {@code null}
* @throws NullPointerException if file is {@code null}.
* @throws IOException if an I/O error occurs, including when the file does not exist, is a directory rather than a
* regular file, or for some other reason why the file cannot be opened for reading.
* @throws java.nio.charset.UnsupportedCharsetException if the named charset is unavailable.
* @since 1.1
*/
public static List readLines(final File file, final String charsetName) throws IOException {
return readLines(file, Charsets.toCharset(charsetName));
}
private static void requireAbsent(final File file, final String name) throws FileExistsException {
if (file.exists()) {
throw new FileExistsException(String.format("File element in parameter '%s' already exists: '%s'", name, file));
}
}
/**
* Throws IllegalArgumentException if the given files' canonical representations are equal.
*
* @param file1 The first file to compare.
* @param file2 The second file to compare.
* @throws IOException if an I/O error occurs.
* @throws IllegalArgumentException if the given files' canonical representations are equal.
*/
private static void requireCanonicalPathsNotEquals(final File file1, final File file2) throws IOException {
final String canonicalPath = file1.getCanonicalPath();
if (canonicalPath.equals(file2.getCanonicalPath())) {
throw new IllegalArgumentException(String
.format("File canonical paths are equal: '%s' (file1='%s', file2='%s')", canonicalPath, file1, file2));
}
}
/**
* Requires that the given {@link File} exists and is a directory.
*
* @param directory The {@link File} to check.
* @param name The parameter name to use in the exception message in case of null input or if the file is not a directory.
* @throws NullPointerException if the given {@link File} is {@code null}.
* @throws FileNotFoundException if the given {@link File} does not exist
* @throws IllegalArgumentException if the given {@link File} exists but is not a directory.
*/
private static void requireDirectoryExists(final File directory, final String name) throws FileNotFoundException {
Objects.requireNonNull(directory, name);
if (!directory.isDirectory()) {
if (directory.exists()) {
throw new IllegalArgumentException("Parameter '" + name + "' is not a directory: '" + directory + "'");
}
throw new FileNotFoundException("Directory '" + directory + "' does not exist.");
}
}
/**
* Requires that the given {@link File} is a directory if it exists.
*
* @param directory The {@link File} to check.
* @param name The parameter name to use in the exception message in case of null input.
* @throws NullPointerException if the given {@link File} is {@code null}.
* @throws IllegalArgumentException if the given {@link File} exists but is not a directory.
*/
private static void requireDirectoryIfExists(final File directory, final String name) throws FileNotFoundException {
Objects.requireNonNull(directory, name);
if (directory.exists() && !directory.isDirectory()) {
throw new IllegalArgumentException("Parameter '" + name + "' is not a directory: '" + directory + "'");
}
}
/**
* Sets file lastModifiedTime, lastAccessTime and creationTime to match source file
*
* @param sourceFile The source file to query.
* @param targetFile The target file or directory to set.
* @return {@code true} if and only if the operation succeeded;
* {@code false} otherwise
* @throws NullPointerException if sourceFile is {@code null}.
* @throws NullPointerException if targetFile is {@code null}.
*/
private static boolean setTimes(final File sourceFile, final File targetFile) {
Objects.requireNonNull(sourceFile, "sourceFile");
Objects.requireNonNull(targetFile, "targetFile");
try {
// Set creation, modified, last accessed to match source file
final BasicFileAttributes srcAttr = Files.readAttributes(sourceFile.toPath(), BasicFileAttributes.class);
final BasicFileAttributeView destAttrView = Files.getFileAttributeView(targetFile.toPath(), BasicFileAttributeView.class);
// null guards are not needed; BasicFileAttributes.setTimes(...) is null safe
destAttrView.setTimes(srcAttr.lastModifiedTime(), srcAttr.lastAccessTime(), srcAttr.creationTime());
return true;
} catch (final IOException ignored) {
// Fallback: Only set modified time to match source file
return targetFile.setLastModified(sourceFile.lastModified());
}
// TODO: (Help!) Determine historically why setLastModified(File, File) needed PathUtils.setLastModifiedTime() if
// sourceFile.isFile() was true, but needed setLastModifiedTime(File, long) if sourceFile.isFile() was false
}
/**
* Returns the size of the specified file or directory. If the provided
* {@link File} is a regular file, then the file's length is returned.
* If the argument is a directory, then the size of the directory is
* calculated recursively. If a directory or subdirectory is security
* restricted, its size will not be included.
*
* Note that overflow is not detected, and the return value may be negative if
* overflow occurs. See {@link #sizeOfAsBigInteger(File)} for an alternative
* method that does not overflow.
*
*
* @param file the regular file or directory to return the size
* of (must not be {@code null}).
*
* @return the length of the file, or recursive size of the directory,
* provided (in bytes).
*
* @throws NullPointerException if the file is {@code null}.
* @throws IllegalArgumentException if the file does not exist.
* @throws UncheckedIOException if an IO error occurs.
* @since 2.0
*/
public static long sizeOf(final File file) {
return Uncheck.get(() -> PathUtils.sizeOf(file.toPath()));
}
/**
* Returns the size of the specified file or directory. If the provided
* {@link File} is a regular file, then the file's length is returned.
* If the argument is a directory, then the size of the directory is
* calculated recursively. If a directory or subdirectory is security
* restricted, its size will not be included.
*
* @param file the regular file or directory to return the size
* of (must not be {@code null}).
*
* @return the length of the file, or recursive size of the directory,
* provided (in bytes).
*
* @throws NullPointerException if the file is {@code null}.
* @throws IllegalArgumentException if the file does not exist.
* @throws UncheckedIOException if an IO error occurs.
* @since 2.4
*/
public static BigInteger sizeOfAsBigInteger(final File file) {
return Uncheck.get(() -> PathUtils.sizeOfAsBigInteger(file.toPath()));
}
/**
* Counts the size of a directory recursively (sum of the length of all files).
*
* Note that overflow is not detected, and the return value may be negative if
* overflow occurs. See {@link #sizeOfDirectoryAsBigInteger(File)} for an alternative
* method that does not overflow.
*
*
* @param directory directory to inspect, must not be {@code null}.
* @return size of directory in bytes, 0 if directory is security restricted, a negative number when the real total
* is greater than {@link Long#MAX_VALUE}.
* @throws IllegalArgumentException if the given {@link File} exists but is not a directory
* @throws NullPointerException if the directory is {@code null}.
* @throws UncheckedIOException if an IO error occurs.
*/
public static long sizeOfDirectory(final File directory) {
try {
requireDirectoryExists(directory, "directory");
} catch (final FileNotFoundException e) {
throw new UncheckedIOException(e);
}
return Uncheck.get(() -> PathUtils.sizeOfDirectory(directory.toPath()));
}
/**
* Counts the size of a directory recursively (sum of the length of all files).
*
* @param directory directory to inspect, must not be {@code null}.
* @return size of directory in bytes, 0 if directory is security restricted.
* @throws IllegalArgumentException if the given {@link File} exists but is not a directory
* @throws NullPointerException if the directory is {@code null}.
* @throws UncheckedIOException if an IO error occurs.
* @since 2.4
*/
public static BigInteger sizeOfDirectoryAsBigInteger(final File directory) {
try {
requireDirectoryExists(directory, "directory");
} catch (final FileNotFoundException e) {
throw new UncheckedIOException(e);
}
return Uncheck.get(() -> PathUtils.sizeOfDirectoryAsBigInteger(directory.toPath()));
}
/**
* Streams over the files in a given directory (and optionally its subdirectories) which match an array of extensions.
*
* The returned {@link Stream} may wrap one or more {@link DirectoryStream}s. When you require timely disposal of file system resources, use a
* {@code try}-with-resources block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed. Calling a
* closed stream causes a {@link IllegalStateException}.
*
*
* @param directory the directory to search in
* @param recursive if true all subdirectories are searched as well
* @param extensions an array of extensions, for example, {"java","xml"}. If this parameter is {@code null}, all files are returned.
* @return a Stream of {@link File} for matching files.
* @throws IOException if an I/O error is thrown when accessing the starting file.
* @since 2.9.0
*/
public static Stream streamFiles(final File directory, final boolean recursive, final String... extensions) throws IOException {
// @formatter:off
final IOFileFilter filter = extensions == null
? FileFileFilter.INSTANCE
: FileFileFilter.INSTANCE.and(new SuffixFileFilter(toSuffixes(extensions)));
// @formatter:on
return PathUtils.walk(directory.toPath(), filter, toMaxDepth(recursive), false, FileVisitOption.FOLLOW_LINKS).map(Path::toFile);
}
/**
* Converts from a {@link URL} to a {@link File}.
*
* Syntax such as {@code file:///my%20docs/file.txt} will be
* correctly decoded to {@code /my docs/file.txt}.
* UTF-8 is used to decode percent-encoded octets to characters.
* Additionally, malformed percent-encoded octets are handled leniently by
* passing them through literally.
*
*
* @param url the file URL to convert, {@code null} returns {@code null}
* @return the equivalent {@link File} object, or {@code null}
* if the URL's protocol is not {@code file}
*/
public static File toFile(final URL url) {
if (url == null || !"file".equalsIgnoreCase(url.getProtocol())) {
return null;
}
final String fileName = url.getFile().replace('/', File.separatorChar);
return new File(decodeUrl(fileName));
}
/**
* Converts each of an array of {@link URL} to a {@link File}.
*
* Returns an array of the same size as the input.
* If the input is {@code null}, an empty array is returned.
* If the input contains {@code null}, the output array contains {@code null} at the same
* index.
*
*
* This method will decode the URL.
* Syntax such as {@code file:///my%20docs/file.txt} will be
* correctly decoded to {@code /my docs/file.txt}.
*
*
* @param urls the file URLs to convert, {@code null} returns empty array
* @return a non-{@code null} array of Files matching the input, with a {@code null} item
* if there was a {@code null} at that index in the input array
* @throws IllegalArgumentException if any file is not a URL file
* @throws IllegalArgumentException if any file is incorrectly encoded
* @since 1.1
*/
public static File[] toFiles(final URL... urls) {
if (IOUtils.length(urls) == 0) {
return EMPTY_FILE_ARRAY;
}
final File[] files = new File[urls.length];
for (int i = 0; i < urls.length; i++) {
final URL url = urls[i];
if (url != null) {
if (!"file".equalsIgnoreCase(url.getProtocol())) {
throw new IllegalArgumentException("Can only convert file URL to a File: " + url);
}
files[i] = toFile(url);
}
}
return files;
}
/**
* Consumes all of the given stream.
*
* When called from a FileTreeWalker, the walker closes the stream because {@link FileTreeWalker#next()} calls {@code top.stream().close()}.
*
*
* @param stream The stream to consume.
* @return a new List.
*/
private static List toList(final Stream stream) {
return stream.collect(Collectors.toList());
}
/**
* Converts whether or not to recurse into a recursion max depth.
*
* @param recursive whether or not to recurse
* @return the recursion depth
*/
private static int toMaxDepth(final boolean recursive) {
return recursive ? Integer.MAX_VALUE : 1;
}
/**
* Converts an array of file extensions to suffixes.
*
* @param extensions an array of extensions. Format: {"java", "xml"}
* @return an array of suffixes. Format: {".java", ".xml"}
* @throws NullPointerException if the parameter is null
*/
private static String[] toSuffixes(final String... extensions) {
return Stream.of(Objects.requireNonNull(extensions, "extensions")).map(e -> "." + e).toArray(String[]::new);
}
/**
* Implements behavior similar to the UNIX "touch" utility. Creates a new file with size 0, or, if the file exists, just
* updates the file's modified time. This method throws an IOException if the last modified date
* of the file cannot be set. It creates parent directories if they do not exist.
*
* @param file the File to touch.
* @throws NullPointerException if the parameter is {@code null}.
* @throws IOException if setting the last-modified time failed or an I/O problem occurs.
*/
public static void touch(final File file) throws IOException {
PathUtils.touch(Objects.requireNonNull(file, "file").toPath());
}
/**
* Converts each element of an array of {@link File} to a {@link URL}.
*
* Returns an array of the same size as the input.
*
*
* @param files the files to convert, must not be {@code null}
* @return an array of URLs matching the input
* @throws IOException if a file cannot be converted
* @throws NullPointerException if any argument is null
*/
public static URL[] toURLs(final File... files) throws IOException {
Objects.requireNonNull(files, "files");
final URL[] urls = new URL[files.length];
for (int i = 0; i < urls.length; i++) {
urls[i] = files[i].toURI().toURL();
}
return urls;
}
/**
* Validates the given arguments.
*
* - Throws {@link NullPointerException} if {@code source} is null
* - Throws {@link NullPointerException} if {@code destination} is null
* - Throws {@link FileNotFoundException} if {@code source} does not exist
*
*
* @param source the file or directory to be moved.
* @param destination the destination file or directory.
* @throws NullPointerException if any of the given {@link File}s are {@code null}.
* @throws FileNotFoundException if the source file does not exist.
*/
private static void validateMoveParameters(final File source, final File destination) throws FileNotFoundException {
Objects.requireNonNull(source, "source");
Objects.requireNonNull(destination, "destination");
if (!source.exists()) {
throw new FileNotFoundException("Source '" + source + "' does not exist");
}
}
/**
* Waits for the file system to propagate a file creation, with a timeout.
*
* This method repeatedly tests {@link Files#exists(Path, LinkOption...)} until it returns
* true up to the maximum time specified in seconds.
*
*
* @param file the file to check, must not be {@code null}
* @param seconds the maximum time in seconds to wait
* @return true if file exists
* @throws NullPointerException if the file is {@code null}
*/
public static boolean waitFor(final File file, final int seconds) {
Objects.requireNonNull(file, "file");
return PathUtils.waitFor(file.toPath(), Duration.ofSeconds(seconds), PathUtils.EMPTY_LINK_OPTION_ARRAY);
}
/**
* Writes a CharSequence to a file creating the file if it does not exist using the default encoding for the VM.
*
* @param file the file to write
* @param data the content to write to the file
* @throws IOException in case of an I/O error
* @since 2.0
* @deprecated Use {@link #write(File, CharSequence, Charset)} instead (and specify the appropriate encoding)
*/
@Deprecated
public static void write(final File file, final CharSequence data) throws IOException {
write(file, data, Charset.defaultCharset(), false);
}
/**
* Writes a CharSequence to a file creating the file if it does not exist using the default encoding for the VM.
*
* @param file the file to write
* @param data the content to write to the file
* @param append if {@code true}, then the data will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @since 2.1
* @deprecated Use {@link #write(File, CharSequence, Charset, boolean)} instead (and specify the appropriate encoding)
*/
@Deprecated
public static void write(final File file, final CharSequence data, final boolean append) throws IOException {
write(file, data, Charset.defaultCharset(), append);
}
/**
* Writes a CharSequence to a file creating the file if it does not exist.
*
* @param file the file to write
* @param data the content to write to the file
* @param charset the name of the requested charset, {@code null} means platform default
* @throws IOException in case of an I/O error
* @since 2.3
*/
public static void write(final File file, final CharSequence data, final Charset charset) throws IOException {
write(file, data, charset, false);
}
/**
* Writes a CharSequence to a file creating the file if it does not exist.
*
* @param file the file to write
* @param data the content to write to the file
* @param charset the charset to use, {@code null} means platform default
* @param append if {@code true}, then the data will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @since 2.3
*/
public static void write(final File file, final CharSequence data, final Charset charset, final boolean append) throws IOException {
writeStringToFile(file, Objects.toString(data, null), charset, append);
}
/**
* Writes a CharSequence to a file creating the file if it does not exist.
*
* @param file the file to write
* @param data the content to write to the file
* @param charsetName the name of the requested charset, {@code null} means platform default
* @throws IOException in case of an I/O error
* @throws java.io.UnsupportedEncodingException if the encoding is not supported by the VM
* @since 2.0
*/
public static void write(final File file, final CharSequence data, final String charsetName) throws IOException {
write(file, data, charsetName, false);
}
/**
* Writes a CharSequence to a file creating the file if it does not exist.
*
* @param file the file to write
* @param data the content to write to the file
* @param charsetName the name of the requested charset, {@code null} means platform default
* @param append if {@code true}, then the data will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported by the VM
* @since 2.1
*/
public static void write(final File file, final CharSequence data, final String charsetName, final boolean append) throws IOException {
write(file, data, Charsets.toCharset(charsetName), append);
}
// Must be called with a directory
/**
* Writes a byte array to a file creating the file if it does not exist.
* The parent directories of the file will be created if they do not exist.
*
* @param file the file to write to
* @param data the content to write to the file
* @throws IOException in case of an I/O error
* @since 1.1
*/
public static void writeByteArrayToFile(final File file, final byte[] data) throws IOException {
writeByteArrayToFile(file, data, false);
}
/**
* Writes a byte array to a file creating the file if it does not exist.
*
* @param file the file to write to
* @param data the content to write to the file
* @param append if {@code true}, then bytes will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @since 2.1
*/
public static void writeByteArrayToFile(final File file, final byte[] data, final boolean append) throws IOException {
writeByteArrayToFile(file, data, 0, data.length, append);
}
/**
* Writes {@code len} bytes from the specified byte array starting
* at offset {@code off} to a file, creating the file if it does
* not exist.
*
* @param file the file to write to
* @param data the content to write to the file
* @param off the start offset in the data
* @param len the number of bytes to write
* @throws IOException in case of an I/O error
* @since 2.5
*/
public static void writeByteArrayToFile(final File file, final byte[] data, final int off, final int len) throws IOException {
writeByteArrayToFile(file, data, off, len, false);
}
/**
* Writes {@code len} bytes from the specified byte array starting
* at offset {@code off} to a file, creating the file if it does
* not exist.
*
* @param file the file to write to
* @param data the content to write to the file
* @param off the start offset in the data
* @param len the number of bytes to write
* @param append if {@code true}, then bytes will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @since 2.5
*/
public static void writeByteArrayToFile(final File file, final byte[] data, final int off, final int len, final boolean append) throws IOException {
try (OutputStream out = newOutputStream(file, append)) {
out.write(data, off, len);
}
}
/**
* Writes the {@code toString()} value of each item in a collection to
* the specified {@link File} line by line.
* The default VM encoding and the default line ending will be used.
*
* @param file the file to write to
* @param lines the lines to write, {@code null} entries produce blank lines
* @throws IOException in case of an I/O error
* @since 1.3
*/
public static void writeLines(final File file, final Collection lines) throws IOException {
writeLines(file, null, lines, null, false);
}
/**
* Writes the {@code toString()} value of each item in a collection to
* the specified {@link File} line by line.
* The default VM encoding and the default line ending will be used.
*
* @param file the file to write to
* @param lines the lines to write, {@code null} entries produce blank lines
* @param append if {@code true}, then the lines will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @since 2.1
*/
public static void writeLines(final File file, final Collection lines, final boolean append) throws IOException {
writeLines(file, null, lines, null, append);
}
/**
* Writes the {@code toString()} value of each item in a collection to
* the specified {@link File} line by line.
* The default VM encoding and the specified line ending will be used.
*
* @param file the file to write to
* @param lines the lines to write, {@code null} entries produce blank lines
* @param lineEnding the line separator to use, {@code null} is system default
* @throws IOException in case of an I/O error
* @since 1.3
*/
public static void writeLines(final File file, final Collection lines, final String lineEnding) throws IOException {
writeLines(file, null, lines, lineEnding, false);
}
/**
* Writes the {@code toString()} value of each item in a collection to
* the specified {@link File} line by line.
* The default VM encoding and the specified line ending will be used.
*
* @param file the file to write to
* @param lines the lines to write, {@code null} entries produce blank lines
* @param lineEnding the line separator to use, {@code null} is system default
* @param append if {@code true}, then the lines will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @since 2.1
*/
public static void writeLines(final File file, final Collection lines, final String lineEnding, final boolean append) throws IOException {
writeLines(file, null, lines, lineEnding, append);
}
/**
* Writes the {@code toString()} value of each item in a collection to
* the specified {@link File} line by line.
* The specified character encoding and the default line ending will be used.
* The parent directories of the file will be created if they do not exist.
*
* @param file the file to write to
* @param charsetName the name of the requested charset, {@code null} means platform default
* @param lines the lines to write, {@code null} entries produce blank lines
* @throws IOException in case of an I/O error
* @throws java.io.UnsupportedEncodingException if the encoding is not supported by the VM
* @since 1.1
*/
public static void writeLines(final File file, final String charsetName, final Collection lines) throws IOException {
writeLines(file, charsetName, lines, null, false);
}
/**
* Writes the {@code toString()} value of each item in a collection to
* the specified {@link File} line by line, optionally appending.
* The specified character encoding and the default line ending will be used.
*
* @param file the file to write to
* @param charsetName the name of the requested charset, {@code null} means platform default
* @param lines the lines to write, {@code null} entries produce blank lines
* @param append if {@code true}, then the lines will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @throws java.io.UnsupportedEncodingException if the encoding is not supported by the VM
* @since 2.1
*/
public static void writeLines(final File file, final String charsetName, final Collection lines, final boolean append) throws IOException {
writeLines(file, charsetName, lines, null, append);
}
/**
* Writes the {@code toString()} value of each item in a collection to
* the specified {@link File} line by line.
* The specified character encoding and the line ending will be used.
* The parent directories of the file will be created if they do not exist.
*
* @param file the file to write to
* @param charsetName the name of the requested charset, {@code null} means platform default
* @param lines the lines to write, {@code null} entries produce blank lines
* @param lineEnding the line separator to use, {@code null} is system default
* @throws IOException in case of an I/O error
* @throws java.io.UnsupportedEncodingException if the encoding is not supported by the VM
* @since 1.1
*/
public static void writeLines(final File file, final String charsetName, final Collection lines, final String lineEnding) throws IOException {
writeLines(file, charsetName, lines, lineEnding, false);
}
/**
* Writes the {@code toString()} value of each item in a collection to
* the specified {@link File} line by line.
* The specified character encoding and the line ending will be used.
*
* @param file the file to write to
* @param charsetName the name of the requested charset, {@code null} means platform default
* @param lines the lines to write, {@code null} entries produce blank lines
* @param lineEnding the line separator to use, {@code null} is system default
* @param append if {@code true}, then the lines will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @throws java.io.UnsupportedEncodingException if the encoding is not supported by the VM
* @since 2.1
*/
public static void writeLines(final File file, final String charsetName, final Collection lines, final String lineEnding, final boolean append)
throws IOException {
try (OutputStream out = new BufferedOutputStream(newOutputStream(file, append))) {
IOUtils.writeLines(lines, lineEnding, out, charsetName);
}
}
/**
* Writes a String to a file creating the file if it does not exist using the default encoding for the VM.
*
* @param file the file to write
* @param data the content to write to the file
* @throws IOException in case of an I/O error
* @deprecated Use {@link #writeStringToFile(File, String, Charset)} instead (and specify the appropriate encoding)
*/
@Deprecated
public static void writeStringToFile(final File file, final String data) throws IOException {
writeStringToFile(file, data, Charset.defaultCharset(), false);
}
/**
* Writes a String to a file creating the file if it does not exist using the default encoding for the VM.
*
* @param file the file to write
* @param data the content to write to the file
* @param append if {@code true}, then the String will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @since 2.1
* @deprecated Use {@link #writeStringToFile(File, String, Charset, boolean)} instead (and specify the appropriate encoding)
*/
@Deprecated
public static void writeStringToFile(final File file, final String data, final boolean append) throws IOException {
writeStringToFile(file, data, Charset.defaultCharset(), append);
}
/**
* Writes a String to a file creating the file if it does not exist.
* The parent directories of the file will be created if they do not exist.
*
* @param file the file to write
* @param data the content to write to the file
* @param charset the charset to use, {@code null} means platform default
* @throws IOException in case of an I/O error
* @throws java.io.UnsupportedEncodingException if the encoding is not supported by the VM
* @since 2.4
*/
public static void writeStringToFile(final File file, final String data, final Charset charset) throws IOException {
writeStringToFile(file, data, charset, false);
}
/**
* Writes a String to a file, creating the file if it does not exist.
* The parent directories of the file are created if they do not exist.
*
* @param file the file to write
* @param data the content to write to the file
* @param charset the charset to use, {@code null} means platform default
* @param append if {@code true}, then the String will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @since 2.3
*/
public static void writeStringToFile(final File file, final String data, final Charset charset, final boolean append) throws IOException {
try (OutputStream out = newOutputStream(file, append)) {
IOUtils.write(data, out, charset);
}
}
/**
* Writes a String to a file, creating the file if it does not exist.
* The parent directories of the file are created if they do not exist.
*
* @param file the file to write
* @param data the content to write to the file
* @param charsetName the name of the requested charset, {@code null} means platform default
* @throws IOException in case of an I/O error
* @throws java.io.UnsupportedEncodingException if the encoding is not supported by the VM
*/
public static void writeStringToFile(final File file, final String data, final String charsetName) throws IOException {
writeStringToFile(file, data, charsetName, false);
}
/**
* Writes a String to a file, creating the file if it does not exist.
* The parent directories of the file are created if they do not exist.
*
* @param file the file to write
* @param data the content to write to the file
* @param charsetName the name of the requested charset, {@code null} means platform default
* @param append if {@code true}, then the String will be added to the
* end of the file rather than overwriting
* @throws IOException in case of an I/O error
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported by the VM
* @since 2.1
*/
public static void writeStringToFile(final File file, final String data, final String charsetName, final boolean append) throws IOException {
writeStringToFile(file, data, Charsets.toCharset(charsetName), append);
}
/**
* Instances should NOT be constructed in standard programming.
*
* @deprecated TODO Make private in 3.0.
*/
@Deprecated
public FileUtils() { //NOSONAR
// empty
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/FilenameUtils.java 0100644 0000000 0000000 00000203627 14603604450 027153 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.File;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Deque;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
/**
* General file name and file path manipulation utilities. The methods in this class
* operate on strings that represent relative or absolute paths. Nothing in this class
* ever accesses the file system, or depends on whether a path points to a file that exists.
*
* When dealing with file names, you can hit problems when moving from a Windows
* based development machine to a UNIX based production machine.
* This class aims to help avoid those problems.
*
*
* NOTE: You may be able to avoid using this class entirely simply by
* using JDK {@link java.io.File File} objects and the two argument constructor
* {@link java.io.File#File(java.io.File, String) File(File,String)}.
*
*
* Most methods in this class are designed to work the same on both UNIX and Windows.
* Those that don't include 'System', 'Unix', or 'Windows' in their name.
*
*
* Most methods recognize both separators (forward and backslashes), and both
* sets of prefixes. See the Javadoc of each method for details.
*
*
* This class defines six components within a path (sometimes called a file name or a full file name).
* Given an absolute Windows path such as C:\dev\project\file.txt they are:
*
*
* - the full file name, or just file name - C:\dev\project\file.txt
* - the prefix - C:\
* - the path - dev\project\
* - the full path - C:\dev\project\
* - the name - file.txt
* - the base name - file
* - the extension - txt
*
*
* Given an absolute UNIX path such as /dev/project/file.txt they are:
*
*
* - the full file name, or just file name - /dev/project/file.txt
* - the prefix - /
* - the path - dev/project
* - the full path - /dev/project
* - the name - file.txt
* - the base name - file
* - the extension - txt
*
*
* Given a relative Windows path such as dev\project\file.txt they are:
*
*
* - the full file name, or just file name - dev\project\file.txt
* - the prefix - null
* - the path - dev\project\
* - the full path - dev\project\
* - the name - file.txt
* - the base name - file
* - the extension - txt
*
*
* Given an absolute UNIX path such as /dev/project/file.txt they are:
*
*
* - the full path, full file name, or just file name - /dev/project/file.txt
* - the prefix - /
* - the path - dev/project
* - the full path - /dev/project
* - the name - file.txt
* - the base name - file
* - the extension - txt
*
*
*
*
* This class works best if directory names end with a separator.
* If you omit the last separator, it is impossible to determine if the last component
* corresponds to a file or a directory. This class treats final components
* that do not end with a separator as files, not directories.
*
*
* This class only supports UNIX and Windows style names.
* Prefixes are matched as follows:
*
*
* Windows:
* a\b\c.txt --> "" --> relative
* \a\b\c.txt --> "\" --> current drive absolute
* C:a\b\c.txt --> "C:" --> drive relative
* C:\a\b\c.txt --> "C:\" --> absolute
* \\server\a\b\c.txt --> "\\server\" --> UNC
*
* Unix:
* a/b/c.txt --> "" --> relative
* /a/b/c.txt --> "/" --> absolute
* ~/a/b/c.txt --> "~/" --> current user
* ~ --> "~/" --> current user (slash added)
* ~user/a/b/c.txt --> "~user/" --> named user
* ~user --> "~user/" --> named user (slash added)
*
*
* Both prefix styles are matched, irrespective of the machine that you are
* currently running on.
*
*
* @since 1.1
*/
public class FilenameUtils {
private static final String[] EMPTY_STRING_ARRAY = {};
private static final String EMPTY_STRING = "";
private static final int NOT_FOUND = -1;
/**
* The extension separator character.
* @since 1.4
*/
public static final char EXTENSION_SEPARATOR = '.';
/**
* The extension separator String.
* @since 1.4
*/
public static final String EXTENSION_SEPARATOR_STR = Character.toString(EXTENSION_SEPARATOR);
/**
* The UNIX separator character.
*/
private static final char UNIX_NAME_SEPARATOR = '/';
/**
* The Windows separator character.
*/
private static final char WINDOWS_NAME_SEPARATOR = '\\';
/**
* The system separator character.
*/
private static final char SYSTEM_NAME_SEPARATOR = File.separatorChar;
/**
* The separator character that is the opposite of the system separator.
*/
private static final char OTHER_SEPARATOR = flipSeparator(SYSTEM_NAME_SEPARATOR);
private static final Pattern IPV4_PATTERN = Pattern.compile("^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$");
private static final int IPV4_MAX_OCTET_VALUE = 255;
private static final int IPV6_MAX_HEX_GROUPS = 8;
private static final int IPV6_MAX_HEX_DIGITS_PER_GROUP = 4;
private static final int MAX_UNSIGNED_SHORT = 0xffff;
private static final int BASE_16 = 16;
private static final Pattern REG_NAME_PART_PATTERN = Pattern.compile("^[a-zA-Z0-9][a-zA-Z0-9-]*$");
/**
* Concatenates a fileName to a base path using normal command line style rules.
*
* The effect is equivalent to resultant directory after changing
* directory to the first argument, followed by changing directory to
* the second argument.
*
*
* The first argument is the base path, the second is the path to concatenate.
* The returned path is always normalized via {@link #normalize(String)},
* thus {@code ..} is handled.
*
*
* If {@code pathToAdd} is absolute (has an absolute prefix), then
* it will be normalized and returned.
* Otherwise, the paths will be joined, normalized and returned.
*
*
* The output will be the same on both UNIX and Windows except
* for the separator character.
*
*
* /foo/ + bar --> /foo/bar
* /foo + bar --> /foo/bar
* /foo + /bar --> /bar
* /foo + C:/bar --> C:/bar
* /foo + C:bar --> C:bar [1]
* /foo/a/ + ../bar --> /foo/bar
* /foo/ + ../../bar --> null
* /foo/ + /bar --> /bar
* /foo/.. + /bar --> /bar
* /foo + bar/c.txt --> /foo/bar/c.txt
* /foo/c.txt + bar --> /foo/c.txt/bar [2]
*
*
* [1] Note that the Windows relative drive prefix is unreliable when
* used with this method.
*
*
* [2] Note that the first parameter must be a path. If it ends with a name, then
* the name will be built into the concatenated path. If this might be a problem,
* use {@link #getFullPath(String)} on the base path argument.
*
*
* @param basePath the base path to attach to, always treated as a path
* @param fullFileNameToAdd the file name (or path) to attach to the base
* @return the concatenated path, or null if invalid
* @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
*/
public static String concat(final String basePath, final String fullFileNameToAdd) {
final int prefix = getPrefixLength(fullFileNameToAdd);
if (prefix < 0) {
return null;
}
if (prefix > 0) {
return normalize(fullFileNameToAdd);
}
if (basePath == null) {
return null;
}
final int len = basePath.length();
if (len == 0) {
return normalize(fullFileNameToAdd);
}
final char ch = basePath.charAt(len - 1);
if (isSeparator(ch)) {
return normalize(basePath + fullFileNameToAdd);
}
return normalize(basePath + '/' + fullFileNameToAdd);
}
/**
* Determines whether the {@code parent} directory contains the {@code child} (a file or directory).
* This does not read from the file system, and there is no guarantee or expectation that
* these paths actually exist.
*
* The files names are expected to be normalized.
*
*
* Edge cases:
*
* - A {@code directory} must not be null: if null, throw IllegalArgumentException
* - A directory does not contain itself: return false
* - A null child file is not contained in any parent: return false
*
*
* @param canonicalParent the path string to consider as the parent.
* @param canonicalChild the path string to consider as the child.
* @return true if the candidate leaf is under the specified composite. False otherwise.
* @since 2.2
* @see FileUtils#directoryContains(File, File)
*/
public static boolean directoryContains(final String canonicalParent, final String canonicalChild) {
if (isEmpty(canonicalParent) || isEmpty(canonicalChild)) {
return false;
}
if (IOCase.SYSTEM.checkEquals(canonicalParent, canonicalChild)) {
return false;
}
final char separator = toSeparator(canonicalParent.charAt(0) == UNIX_NAME_SEPARATOR);
final String parentWithEndSeparator = canonicalParent.charAt(canonicalParent.length() - 1) == separator ? canonicalParent : canonicalParent + separator;
return IOCase.SYSTEM.checkStartsWith(canonicalChild, parentWithEndSeparator);
}
/**
* Does the work of getting the path.
*
* @param fileName the file name
* @param includeSeparator true to include the end separator
* @return the path
* @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
*/
private static String doGetFullPath(final String fileName, final boolean includeSeparator) {
if (fileName == null) {
return null;
}
final int prefix = getPrefixLength(fileName);
if (prefix < 0) {
return null;
}
if (prefix >= fileName.length()) {
if (includeSeparator) {
return getPrefix(fileName); // add end slash if necessary
}
return fileName;
}
final int index = indexOfLastSeparator(fileName);
if (index < 0) {
return fileName.substring(0, prefix);
}
int end = index + (includeSeparator ? 1 : 0);
if (end == 0) {
end++;
}
return fileName.substring(0, end);
}
/**
* Does the work of getting the path.
*
* @param fileName the file name
* @param separatorAdd 0 to omit the end separator, 1 to return it
* @return the path
* @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
*/
private static String doGetPath(final String fileName, final int separatorAdd) {
if (fileName == null) {
return null;
}
final int prefix = getPrefixLength(fileName);
if (prefix < 0) {
return null;
}
final int index = indexOfLastSeparator(fileName);
final int endIndex = index + separatorAdd;
if (prefix >= fileName.length() || index < 0 || prefix >= endIndex) {
return EMPTY_STRING;
}
return requireNonNullChars(fileName.substring(prefix, endIndex));
}
/**
* Internal method to perform the normalization.
*
* @param fileName the file name
* @param separator The separator character to use
* @param keepSeparator true to keep the final separator
* @return the normalized fileName
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
*/
private static String doNormalize(final String fileName, final char separator, final boolean keepSeparator) {
if (fileName == null) {
return null;
}
requireNonNullChars(fileName);
int size = fileName.length();
if (size == 0) {
return fileName;
}
final int prefix = getPrefixLength(fileName);
if (prefix < 0) {
return null;
}
final char[] array = new char[size + 2]; // +1 for possible extra slash, +2 for arraycopy
fileName.getChars(0, fileName.length(), array, 0);
// fix separators throughout
final char otherSeparator = flipSeparator(separator);
for (int i = 0; i < array.length; i++) {
if (array[i] == otherSeparator) {
array[i] = separator;
}
}
// add extra separator on the end to simplify code below
boolean lastIsDirectory = true;
if (array[size - 1] != separator) {
array[size++] = separator;
lastIsDirectory = false;
}
// adjoining slashes
// If we get here, prefix can only be 0 or greater, size 1 or greater
// If prefix is 0, set loop start to 1 to prevent index errors
for (int i = prefix != 0 ? prefix : 1; i < size; i++) {
if (array[i] == separator && array[i - 1] == separator) {
System.arraycopy(array, i, array, i - 1, size - i);
size--;
i--;
}
}
// dot slash
for (int i = prefix + 1; i < size; i++) {
if (array[i] == separator && array[i - 1] == '.' &&
(i == prefix + 1 || array[i - 2] == separator)) {
if (i == size - 1) {
lastIsDirectory = true;
}
System.arraycopy(array, i + 1, array, i - 1, size - i);
size -=2;
i--;
}
}
// double dot slash
outer:
for (int i = prefix + 2; i < size; i++) {
if (array[i] == separator && array[i - 1] == '.' && array[i - 2] == '.' &&
(i == prefix + 2 || array[i - 3] == separator)) {
if (i == prefix + 2) {
return null;
}
if (i == size - 1) {
lastIsDirectory = true;
}
int j;
for (j = i - 4 ; j >= prefix; j--) {
if (array[j] == separator) {
// remove b/../ from a/b/../c
System.arraycopy(array, i + 1, array, j + 1, size - i);
size -= i - j;
i = j + 1;
continue outer;
}
}
// remove a/../ from a/../c
System.arraycopy(array, i + 1, array, prefix, size - i);
size -= i + 1 - prefix;
i = prefix + 1;
}
}
if (size <= 0) { // should never be less than 0
return EMPTY_STRING;
}
if (size <= prefix) { // should never be less than prefix
return new String(array, 0, size);
}
if (lastIsDirectory && keepSeparator) {
return new String(array, 0, size); // keep trailing separator
}
return new String(array, 0, size - 1); // lose trailing separator
}
/**
* Checks whether two file names are exactly equal.
*
* No processing is performed on the file names other than comparison.
* This is merely a null-safe case-sensitive string equality.
*
*
* @param fileName1 the first file name, may be null
* @param fileName2 the second file name, may be null
* @return true if the file names are equal, null equals null
* @see IOCase#SENSITIVE
*/
public static boolean equals(final String fileName1, final String fileName2) {
return equals(fileName1, fileName2, false, IOCase.SENSITIVE);
}
/**
* Checks whether two file names are equal, optionally normalizing and providing
* control over the case-sensitivity.
*
* @param fileName1 the first file name, may be null
* @param fileName2 the second file name, may be null
* @param normalize whether to normalize the file names
* @param ioCase what case sensitivity rule to use, null means case-sensitive
* @return true if the file names are equal, null equals null
* @since 1.3
*/
public static boolean equals(String fileName1, String fileName2, final boolean normalize, final IOCase ioCase) {
if (fileName1 == null || fileName2 == null) {
return fileName1 == null && fileName2 == null;
}
if (normalize) {
fileName1 = normalize(fileName1);
if (fileName1 == null) {
return false;
}
fileName2 = normalize(fileName2);
if (fileName2 == null) {
return false;
}
}
return IOCase.value(ioCase, IOCase.SENSITIVE).checkEquals(fileName1, fileName2);
}
/**
* Checks whether two file names are equal after both have been normalized.
*
* Both file names are first passed to {@link #normalize(String)}.
* The check is then performed in a case-sensitive manner.
*
*
* @param fileName1 the first file name, may be null
* @param fileName2 the second file name, may be null
* @return true if the file names are equal, null equals null
* @see IOCase#SENSITIVE
*/
public static boolean equalsNormalized(final String fileName1, final String fileName2) {
return equals(fileName1, fileName2, true, IOCase.SENSITIVE);
}
/**
* Checks whether two file names are equal using the case rules of the system
* after both have been normalized.
*
* Both file names are first passed to {@link #normalize(String)}.
* The check is then performed case-sensitively on UNIX and
* case-insensitively on Windows.
*
*
* @param fileName1 the first file name, may be null
* @param fileName2 the second file name, may be null
* @return true if the file names are equal, null equals null
* @see IOCase#SYSTEM
*/
public static boolean equalsNormalizedOnSystem(final String fileName1, final String fileName2) {
return equals(fileName1, fileName2, true, IOCase.SYSTEM);
}
/**
* Checks whether two file names are equal using the case rules of the system.
*
* No processing is performed on the file names other than comparison.
* The check is case-sensitive on UNIX and case-insensitive on Windows.
*
*
* @param fileName1 the first file name, may be null
* @param fileName2 the second file name, may be null
* @return true if the file names are equal, null equals null
* @see IOCase#SYSTEM
*/
public static boolean equalsOnSystem(final String fileName1, final String fileName2) {
return equals(fileName1, fileName2, false, IOCase.SYSTEM);
}
/**
* Flips the Windows name separator to Linux and vice-versa.
*
* @param ch The Windows or Linux name separator.
* @return The Windows or Linux name separator.
*/
static char flipSeparator(final char ch) {
if (ch == UNIX_NAME_SEPARATOR) {
return WINDOWS_NAME_SEPARATOR;
}
if (ch == WINDOWS_NAME_SEPARATOR) {
return UNIX_NAME_SEPARATOR;
}
throw new IllegalArgumentException(String.valueOf(ch));
}
/**
* Special handling for NTFS ADS: Don't accept colon in the file name.
*
* @param fileName a file name
* @return ADS offsets.
*/
private static int getAdsCriticalOffset(final String fileName) {
// Step 1: Remove leading path segments.
final int offset1 = fileName.lastIndexOf(SYSTEM_NAME_SEPARATOR);
final int offset2 = fileName.lastIndexOf(OTHER_SEPARATOR);
if (offset1 == -1) {
if (offset2 == -1) {
return 0;
}
return offset2 + 1;
}
if (offset2 == -1) {
return offset1 + 1;
}
return Math.max(offset1, offset2) + 1;
}
/**
* Gets the base name, minus the full path and extension, from a full file name.
*
* This method will handle a path in either UNIX or Windows format.
* The text after the last forward or backslash and before the last dot is returned.
*
*
* a/b/c.txt --> c
* a\b\c.txt --> c
* a/b/c.foo.txt --> c.foo
* a.txt --> a
* a/b/c --> c
* a/b/c/ --> ""
*
*
* The output will be the same irrespective of the machine that the code is running on.
*
*
* @param fileName the file name, null returns null
* @return the name of the file without the path, or an empty string if none exists
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
*/
public static String getBaseName(final String fileName) {
return removeExtension(getName(fileName));
}
/**
* Gets the extension of a fileName.
*
* This method returns the textual part of the file name after the last dot.
* There must be no directory separator after the dot.
*
*
* foo.txt --> "txt"
* a/b/c.jpg --> "jpg"
* a/b.txt/c --> ""
* a/b/c --> ""
*
*
* The output will be the same irrespective of the machine that the code is running on, with the
* exception of a possible {@link IllegalArgumentException} on Windows (see below).
*
*
* Note: This method used to have a hidden problem for names like "foo.exe:bar.txt".
* In this case, the name wouldn't be the name of a file, but the identifier of an
* alternate data stream (bar.txt) on the file foo.exe. The method used to return
* ".txt" here, which would be misleading. Commons IO 2.7 and later throw
* an {@link IllegalArgumentException} for names like this.
*
*
* @param fileName the file name to retrieve the extension of.
* @return the extension of the file or an empty string if none exists or {@code null}
* if the file name is {@code null}.
* @throws IllegalArgumentException Windows only: the file name parameter is, in fact,
* the identifier of an Alternate Data Stream, for example "foo.exe:bar.txt".
*/
public static String getExtension(final String fileName) throws IllegalArgumentException {
if (fileName == null) {
return null;
}
final int index = indexOfExtension(fileName);
if (index == NOT_FOUND) {
return EMPTY_STRING;
}
return fileName.substring(index + 1);
}
/**
* Gets the full path (prefix + path) from a full file name.
*
* This method will handle a file in either UNIX or Windows format.
* The method is entirely text based, and returns the text before and
* including the last forward or backslash.
*
*
* C:\a\b\c.txt --> C:\a\b\
* ~/a/b/c.txt --> ~/a/b/
* a.txt --> ""
* a/b/c --> a/b/
* a/b/c/ --> a/b/c/
* C: --> C:
* C:\ --> C:\
* ~ --> ~/
* ~/ --> ~/
* ~user --> ~user/
* ~user/ --> ~user/
*
*
* The output will be the same irrespective of the machine that the code is running on.
*
*
* @param fileName the file name, null returns null
* @return the path of the file, an empty string if none exists, null if invalid
* @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
*/
public static String getFullPath(final String fileName) {
return doGetFullPath(fileName, true);
}
/**
* Gets the full path (prefix + path) from a full file name,
* excluding the final directory separator.
*
* This method will handle a file in either UNIX or Windows format.
* The method is entirely text based, and returns the text before the
* last forward or backslash.
*
*
* C:\a\b\c.txt --> C:\a\b
* ~/a/b/c.txt --> ~/a/b
* a.txt --> ""
* a/b/c --> a/b
* a/b/c/ --> a/b/c
* C: --> C:
* C:\ --> C:\
* ~ --> ~
* ~/ --> ~
* ~user --> ~user
* ~user/ --> ~user
*
*
* The output will be the same irrespective of the machine that the code is running on.
*
*
* @param fileName the file name, null returns null
* @return the path of the file, an empty string if none exists, null if invalid
* @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
*/
public static String getFullPathNoEndSeparator(final String fileName) {
return doGetFullPath(fileName, false);
}
/**
* Gets the name minus the path from a full file name.
*
* This method will handle a file in either UNIX or Windows format.
* The text after the last forward or backslash is returned.
*
*
* a/b/c.txt --> c.txt
* a\b\c.txt --> c.txt
* a.txt --> a.txt
* a/b/c --> c
* a/b/c/ --> ""
*
*
* The output will be the same irrespective of the machine that the code is running on.
*
*
* @param fileName the file name, null returns null
* @return the name of the file without the path, or an empty string if none exists
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
*/
public static String getName(final String fileName) {
if (fileName == null) {
return null;
}
return requireNonNullChars(fileName).substring(indexOfLastSeparator(fileName) + 1);
}
/**
* Gets the path from a full file name, which excludes the prefix and the name.
*
* This method will handle a file in either UNIX or Windows format.
* The method is entirely text based, and returns the text before and
* including the last forward or backslash.
*
*
* C:\a\b\c.txt --> a\b\
* ~/a/b/c.txt --> a/b/
* a.txt --> ""
* a/b/c --> a/b/
* a/b/c/ --> a/b/c/
*
*
* The output will be the same irrespective of the machine that the code is running on.
*
*
* This method drops the prefix from the result.
* See {@link #getFullPath(String)} for the method that retains the prefix.
*
*
* @param fileName the file name, null returns null
* @return the path of the file, an empty string if none exists, null if invalid
* @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
*/
public static String getPath(final String fileName) {
return doGetPath(fileName, 1);
}
/**
* Gets the path (which excludes the prefix) from a full file name, and
* also excluding the final directory separator.
*
* This method will handle a file in either UNIX or Windows format.
* The method is entirely text based, and returns the text before the
* last forward or backslash.
*
*
* C:\a\b\c.txt --> a\b
* ~/a/b/c.txt --> a/b
* a.txt --> ""
* a/b/c --> a/b
* a/b/c/ --> a/b/c
*
*
* The output will be the same irrespective of the machine that the code is running on.
*
*
* This method drops the prefix from the result.
* See {@link #getFullPathNoEndSeparator(String)} for the method that retains the prefix.
*
*
* @param fileName the file name, null returns null
* @return the path of the file, an empty string if none exists, null if invalid
* @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
*/
public static String getPathNoEndSeparator(final String fileName) {
return doGetPath(fileName, 0);
}
/**
* Gets the prefix such as {@code C:/} or {@code ~/} from a full file name,
*
* This method will handle a file in either UNIX or Windows format.
* The prefix includes the first slash in the full file name where applicable.
*
*
* Windows:
* a\b\c.txt --> "" --> relative
* \a\b\c.txt --> "\" --> current drive absolute
* C:a\b\c.txt --> "C:" --> drive relative
* C:\a\b\c.txt --> "C:\" --> absolute
* \\server\a\b\c.txt --> "\\server\" --> UNC
*
* Unix:
* a/b/c.txt --> "" --> relative
* /a/b/c.txt --> "/" --> absolute
* ~/a/b/c.txt --> "~/" --> current user
* ~ --> "~/" --> current user (slash added)
* ~user/a/b/c.txt --> "~user/" --> named user
* ~user --> "~user/" --> named user (slash added)
*
*
* The output will be the same irrespective of the machine that the code is running on.
* ie. both UNIX and Windows prefixes are matched regardless.
*
*
* @param fileName the file name, null returns null
* @return the prefix of the file, null if invalid
* @throws IllegalArgumentException if the result contains the null character ({@code U+0000})
*/
public static String getPrefix(final String fileName) {
if (fileName == null) {
return null;
}
final int len = getPrefixLength(fileName);
if (len < 0) {
return null;
}
if (len > fileName.length()) {
requireNonNullChars(fileName);
return fileName + UNIX_NAME_SEPARATOR;
}
return requireNonNullChars(fileName.substring(0, len));
}
/**
* Returns the length of the file name prefix, such as {@code C:/} or {@code ~/}.
*
* This method will handle a file in either UNIX or Windows format.
*
*
* The prefix length includes the first slash in the full file name
* if applicable. Thus, it is possible that the length returned is greater
* than the length of the input string.
*
*
* Windows:
* a\b\c.txt --> 0 --> relative
* \a\b\c.txt --> 1 --> current drive absolute
* C:a\b\c.txt --> 2 --> drive relative
* C:\a\b\c.txt --> 3 --> absolute
* \\server\a\b\c.txt --> 9 --> UNC
* \\\a\b\c.txt --> -1 --> error
*
* Unix:
* a/b/c.txt --> 0 --> relative
* /a/b/c.txt --> 1 --> absolute
* ~/a/b/c.txt --> 2 --> current user
* ~ --> 2 --> current user (slash added)
* ~user/a/b/c.txt --> 6 --> named user
* ~user --> 6 --> named user (slash added)
* //server/a/b/c.txt --> 9
* ///a/b/c.txt --> -1 --> error
* C: --> 0 --> valid file name as only null character and / are reserved characters
*
*
* The output will be the same irrespective of the machine that the code is running on.
* ie. both UNIX and Windows prefixes are matched regardless.
*
*
* Note that a leading // (or \\) is used to indicate a UNC name on Windows.
* These must be followed by a server name, so double-slashes are not collapsed
* to a single slash at the start of the file name.
*
*
* @param fileName the file name to find the prefix in, null returns -1
* @return the length of the prefix, -1 if invalid or null
*/
public static int getPrefixLength(final String fileName) {
if (fileName == null) {
return NOT_FOUND;
}
final int len = fileName.length();
if (len == 0) {
return 0;
}
char ch0 = fileName.charAt(0);
if (ch0 == ':') {
return NOT_FOUND;
}
if (len == 1) {
if (ch0 == '~') {
return 2; // return a length greater than the input
}
return isSeparator(ch0) ? 1 : 0;
}
if (ch0 == '~') {
int posUnix = fileName.indexOf(UNIX_NAME_SEPARATOR, 1);
int posWin = fileName.indexOf(WINDOWS_NAME_SEPARATOR, 1);
if (posUnix == NOT_FOUND && posWin == NOT_FOUND) {
return len + 1; // return a length greater than the input
}
posUnix = posUnix == NOT_FOUND ? posWin : posUnix;
posWin = posWin == NOT_FOUND ? posUnix : posWin;
return Math.min(posUnix, posWin) + 1;
}
final char ch1 = fileName.charAt(1);
if (ch1 == ':') {
ch0 = Character.toUpperCase(ch0);
if (ch0 >= 'A' && ch0 <= 'Z') {
if (len == 2 && !FileSystem.getCurrent().supportsDriveLetter()) {
return 0;
}
if (len == 2 || !isSeparator(fileName.charAt(2))) {
return 2;
}
return 3;
}
if (ch0 == UNIX_NAME_SEPARATOR) {
return 1;
}
return NOT_FOUND;
}
if (!isSeparator(ch0) || !isSeparator(ch1)) {
return isSeparator(ch0) ? 1 : 0;
}
int posUnix = fileName.indexOf(UNIX_NAME_SEPARATOR, 2);
int posWin = fileName.indexOf(WINDOWS_NAME_SEPARATOR, 2);
if (posUnix == NOT_FOUND && posWin == NOT_FOUND || posUnix == 2 || posWin == 2) {
return NOT_FOUND;
}
posUnix = posUnix == NOT_FOUND ? posWin : posUnix;
posWin = posWin == NOT_FOUND ? posUnix : posWin;
final int pos = Math.min(posUnix, posWin) + 1;
final String hostnamePart = fileName.substring(2, pos - 1);
return isValidHostName(hostnamePart) ? pos : NOT_FOUND;
}
/**
* Returns the index of the last extension separator character, which is a dot.
*
* This method also checks that there is no directory separator after the last dot. To do this it uses
* {@link #indexOfLastSeparator(String)} which will handle a file in either UNIX or Windows format.
*
*
* The output will be the same irrespective of the machine that the code is running on, with the
* exception of a possible {@link IllegalArgumentException} on Windows (see below).
*
* Note: This method used to have a hidden problem for names like "foo.exe:bar.txt".
* In this case, the name wouldn't be the name of a file, but the identifier of an
* alternate data stream (bar.txt) on the file foo.exe. The method used to return
* ".txt" here, which would be misleading. Commons IO 2.7, and later versions, are throwing
* an {@link IllegalArgumentException} for names like this.
*
* @param fileName
* the file name to find the last extension separator in, null returns -1
* @return the index of the last extension separator character, or -1 if there is no such character
* @throws IllegalArgumentException Windows only: the file name parameter is, in fact,
* the identifier of an Alternate Data Stream, for example "foo.exe:bar.txt".
*/
public static int indexOfExtension(final String fileName) throws IllegalArgumentException {
if (fileName == null) {
return NOT_FOUND;
}
if (isSystemWindows()) {
// Special handling for NTFS ADS: Don't accept colon in the file name.
final int offset = fileName.indexOf(':', getAdsCriticalOffset(fileName));
if (offset != -1) {
throw new IllegalArgumentException("NTFS ADS separator (':') in file name is forbidden.");
}
}
final int extensionPos = fileName.lastIndexOf(EXTENSION_SEPARATOR);
final int lastSeparator = indexOfLastSeparator(fileName);
return lastSeparator > extensionPos ? NOT_FOUND : extensionPos;
}
/**
* Returns the index of the last directory separator character.
*
* This method will handle a file in either UNIX or Windows format.
* The position of the last forward or backslash is returned.
*
* The output will be the same irrespective of the machine that the code is running on.
*
* @param fileName the file name to find the last path separator in, null returns -1
* @return the index of the last separator character, or -1 if there
* is no such character
*/
public static int indexOfLastSeparator(final String fileName) {
if (fileName == null) {
return NOT_FOUND;
}
final int lastUnixPos = fileName.lastIndexOf(UNIX_NAME_SEPARATOR);
final int lastWindowsPos = fileName.lastIndexOf(WINDOWS_NAME_SEPARATOR);
return Math.max(lastUnixPos, lastWindowsPos);
}
private static boolean isEmpty(final String string) {
return string == null || string.isEmpty();
}
/**
* Checks whether the extension of the file name is one of those specified.
*
* This method obtains the extension as the textual part of the file name
* after the last dot. There must be no directory separator after the dot.
* The extension check is case-sensitive on all platforms.
*
* @param fileName the file name, null returns false
* @param extensions the extensions to check for, null checks for no extension
* @return true if the file name is one of the extensions
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
*/
public static boolean isExtension(final String fileName, final Collection extensions) {
if (fileName == null) {
return false;
}
requireNonNullChars(fileName);
if (extensions == null || extensions.isEmpty()) {
return indexOfExtension(fileName) == NOT_FOUND;
}
return extensions.contains(getExtension(fileName));
}
/**
* Checks whether the extension of the file name is that specified.
*
* This method obtains the extension as the textual part of the file name
* after the last dot. There must be no directory separator after the dot.
* The extension check is case-sensitive on all platforms.
*
* @param fileName the file name, null returns false
* @param extension the extension to check for, null or empty checks for no extension
* @return true if the file name has the specified extension
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
*/
public static boolean isExtension(final String fileName, final String extension) {
if (fileName == null) {
return false;
}
requireNonNullChars(fileName);
if (isEmpty(extension)) {
return indexOfExtension(fileName) == NOT_FOUND;
}
return getExtension(fileName).equals(extension);
}
/**
* Checks whether the extension of the file name is one of those specified.
*
* This method obtains the extension as the textual part of the file name
* after the last dot. There must be no directory separator after the dot.
* The extension check is case-sensitive on all platforms.
*
* @param fileName the file name, null returns false
* @param extensions the extensions to check for, null checks for no extension
* @return true if the file name is one of the extensions
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
*/
public static boolean isExtension(final String fileName, final String... extensions) {
if (fileName == null) {
return false;
}
requireNonNullChars(fileName);
if (extensions == null || extensions.length == 0) {
return indexOfExtension(fileName) == NOT_FOUND;
}
final String fileExt = getExtension(fileName);
return Stream.of(extensions).anyMatch(fileExt::equals);
}
/**
* Checks whether a given string represents a valid IPv4 address.
*
* @param name the name to validate
* @return true if the given name is a valid IPv4 address
*/
// mostly copied from org.apache.commons.validator.routines.InetAddressValidator#isValidInet4Address
private static boolean isIPv4Address(final String name) {
final Matcher m = IPV4_PATTERN.matcher(name);
if (!m.matches() || m.groupCount() != 4) {
return false;
}
// verify that address subgroups are legal
for (int i = 1; i <= 4; i++) {
final String ipSegment = m.group(i);
final int iIpSegment = Integer.parseInt(ipSegment);
if (iIpSegment > IPV4_MAX_OCTET_VALUE) {
return false;
}
if (ipSegment.length() > 1 && ipSegment.startsWith("0")) {
return false;
}
}
return true;
}
// copied from org.apache.commons.validator.routines.InetAddressValidator#isValidInet6Address
/**
* Checks whether a given string represents a valid IPv6 address.
*
* @param inet6Address the name to validate
* @return true if the given name is a valid IPv6 address
*/
private static boolean isIPv6Address(final String inet6Address) {
final boolean containsCompressedZeroes = inet6Address.contains("::");
if (containsCompressedZeroes && inet6Address.indexOf("::") != inet6Address.lastIndexOf("::")) {
return false;
}
if (inet6Address.startsWith(":") && !inet6Address.startsWith("::")
|| inet6Address.endsWith(":") && !inet6Address.endsWith("::")) {
return false;
}
String[] octets = inet6Address.split(":");
if (containsCompressedZeroes) {
final List octetList = new ArrayList<>(Arrays.asList(octets));
if (inet6Address.endsWith("::")) {
// String.split() drops ending empty segments
octetList.add("");
} else if (inet6Address.startsWith("::") && !octetList.isEmpty()) {
octetList.remove(0);
}
octets = octetList.toArray(EMPTY_STRING_ARRAY);
}
if (octets.length > IPV6_MAX_HEX_GROUPS) {
return false;
}
int validOctets = 0;
int emptyOctets = 0; // consecutive empty chunks
for (int index = 0; index < octets.length; index++) {
final String octet = octets[index];
if (octet.isEmpty()) {
emptyOctets++;
if (emptyOctets > 1) {
return false;
}
} else {
emptyOctets = 0;
// Is last chunk an IPv4 address?
if (index == octets.length - 1 && octet.contains(".")) {
if (!isIPv4Address(octet)) {
return false;
}
validOctets += 2;
continue;
}
if (octet.length() > IPV6_MAX_HEX_DIGITS_PER_GROUP) {
return false;
}
final int octetInt;
try {
octetInt = Integer.parseInt(octet, BASE_16);
} catch (final NumberFormatException e) {
return false;
}
if (octetInt < 0 || octetInt > MAX_UNSIGNED_SHORT) {
return false;
}
}
validOctets++;
}
return validOctets <= IPV6_MAX_HEX_GROUPS && (validOctets >= IPV6_MAX_HEX_GROUPS || containsCompressedZeroes);
}
/**
* Checks whether a given string is a valid host name according to
* RFC 3986 - not accepting IP addresses.
*
* @see "https://tools.ietf.org/html/rfc3986#section-3.2.2"
* @param name the hostname to validate
* @return true if the given name is a valid host name
*/
private static boolean isRFC3986HostName(final String name) {
final String[] parts = name.split("\\.", -1);
for (int i = 0; i < parts.length; i++) {
if (parts[i].isEmpty()) {
// trailing dot is legal, otherwise we've hit a .. sequence
return i == parts.length - 1;
}
if (!REG_NAME_PART_PATTERN.matcher(parts[i]).matches()) {
return false;
}
}
return true;
}
/**
* Checks if the character is a separator.
*
* @param ch the character to check
* @return true if it is a separator character
*/
private static boolean isSeparator(final char ch) {
return ch == UNIX_NAME_SEPARATOR || ch == WINDOWS_NAME_SEPARATOR;
}
/**
* Determines if Windows file system is in use.
*
* @return true if the system is Windows
*/
static boolean isSystemWindows() {
return SYSTEM_NAME_SEPARATOR == WINDOWS_NAME_SEPARATOR;
}
/**
* Checks whether a given string is a valid host name according to
* RFC 3986.
*
* Accepted are IP addresses (v4 and v6) as well as what the
* RFC calls a "reg-name". Percent encoded names don't seem to be
* valid names in UNC paths.
*
* @see "https://tools.ietf.org/html/rfc3986#section-3.2.2"
* @param name the hostname to validate
* @return true if the given name is a valid host name
*/
private static boolean isValidHostName(final String name) {
return isIPv6Address(name) || isRFC3986HostName(name);
}
/**
* Normalizes a path, removing double and single dot path steps.
*
* This method normalizes a path to a standard format.
* The input may contain separators in either UNIX or Windows format.
* The output will contain separators in the format of the system.
*
* A trailing slash will be retained.
* A double slash will be merged to a single slash (but UNC names are handled).
* A single dot path segment will be removed.
* A double dot will cause that path segment and the one before to be removed.
* If the double dot has no parent path segment, {@code null} is returned.
*
* The output will be the same on both UNIX and Windows except
* for the separator character.
*
* /foo// --> /foo/
* /foo/./ --> /foo/
* /foo/../bar --> /bar
* /foo/../bar/ --> /bar/
* /foo/../bar/../baz --> /baz
* //foo//./bar --> //foo/bar
* /../ --> null
* ../foo --> null
* foo/bar/.. --> foo/
* foo/../../bar --> null
* foo/../bar --> bar
* //server/foo/../bar --> //server/bar
* //server/../bar --> null
* C:\foo\..\bar --> C:\bar
* C:\..\bar --> null
* ~/foo/../bar/ --> ~/bar/
* ~/../bar --> null
*
* (Note the file separator will be correct for Windows/Unix.)
*
* @param fileName the file name to normalize, null returns null
* @return the normalized fileName, or null if invalid
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
*/
public static String normalize(final String fileName) {
return doNormalize(fileName, SYSTEM_NAME_SEPARATOR, true);
}
/**
* Normalizes a path, removing double and single dot path steps.
*
* This method normalizes a path to a standard format.
* The input may contain separators in either UNIX or Windows format.
* The output will contain separators in the format specified.
*
* A trailing slash will be retained.
* A double slash will be merged to a single slash (but UNC names are handled).
* A single dot path segment will be removed.
* A double dot will cause that path segment and the one before to be removed.
* If the double dot has no parent path segment to work with, {@code null}
* is returned.
*
* The output will be the same on both UNIX and Windows except
* for the separator character.
*
* /foo// --> /foo/
* /foo/./ --> /foo/
* /foo/../bar --> /bar
* /foo/../bar/ --> /bar/
* /foo/../bar/../baz --> /baz
* //foo//./bar --> /foo/bar
* /../ --> null
* ../foo --> null
* foo/bar/.. --> foo/
* foo/../../bar --> null
* foo/../bar --> bar
* //server/foo/../bar --> //server/bar
* //server/../bar --> null
* C:\foo\..\bar --> C:\bar
* C:\..\bar --> null
* ~/foo/../bar/ --> ~/bar/
* ~/../bar --> null
*
* The output will be the same on both UNIX and Windows including
* the separator character.
*
* @param fileName the file name to normalize, null returns null
* @param unixSeparator {@code true} if a UNIX separator should
* be used or {@code false} if a Windows separator should be used.
* @return the normalized fileName, or null if invalid
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
* @since 2.0
*/
public static String normalize(final String fileName, final boolean unixSeparator) {
return doNormalize(fileName, toSeparator(unixSeparator), true);
}
/**
* Normalizes a path, removing double and single dot path steps,
* and removing any final directory separator.
*
* This method normalizes a path to a standard format.
* The input may contain separators in either UNIX or Windows format.
* The output will contain separators in the format of the system.
*
* A trailing slash will be removed.
* A double slash will be merged to a single slash (but UNC names are handled).
* A single dot path segment will be removed.
* A double dot will cause that path segment and the one before to be removed.
* If the double dot has no parent path segment to work with, {@code null}
* is returned.
*
* The output will be the same on both UNIX and Windows except
* for the separator character.
*
* /foo// --> /foo
* /foo/./ --> /foo
* /foo/../bar --> /bar
* /foo/../bar/ --> /bar
* /foo/../bar/../baz --> /baz
* //foo//./bar --> /foo/bar
* /../ --> null
* ../foo --> null
* foo/bar/.. --> foo
* foo/../../bar --> null
* foo/../bar --> bar
* //server/foo/../bar --> //server/bar
* //server/../bar --> null
* C:\foo\..\bar --> C:\bar
* C:\..\bar --> null
* ~/foo/../bar/ --> ~/bar
* ~/../bar --> null
*
* (Note the file separator returned will be correct for Windows/Unix)
*
* @param fileName the file name to normalize, null returns null
* @return the normalized fileName, or null if invalid
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
*/
public static String normalizeNoEndSeparator(final String fileName) {
return doNormalize(fileName, SYSTEM_NAME_SEPARATOR, false);
}
/**
* Normalizes a path, removing double and single dot path steps,
* and removing any final directory separator.
*
* This method normalizes a path to a standard format.
* The input may contain separators in either UNIX or Windows format.
* The output will contain separators in the format specified.
*
* A trailing slash will be removed.
* A double slash will be merged to a single slash (but UNC names are handled).
* A single dot path segment will be removed.
* A double dot will cause that path segment and the one before to be removed.
* If the double dot has no parent path segment to work with, {@code null}
* is returned.
*
* The output will be the same on both UNIX and Windows including
* the separator character.
*
* /foo// --> /foo
* /foo/./ --> /foo
* /foo/../bar --> /bar
* /foo/../bar/ --> /bar
* /foo/../bar/../baz --> /baz
* //foo//./bar --> /foo/bar
* /../ --> null
* ../foo --> null
* foo/bar/.. --> foo
* foo/../../bar --> null
* foo/../bar --> bar
* //server/foo/../bar --> //server/bar
* //server/../bar --> null
* C:\foo\..\bar --> C:\bar
* C:\..\bar --> null
* ~/foo/../bar/ --> ~/bar
* ~/../bar --> null
*
*
* @param fileName the file name to normalize, null returns null
* @param unixSeparator {@code true} if a UNIX separator should
* be used or {@code false} if a Windows separator should be used.
* @return the normalized fileName, or null if invalid
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
* @since 2.0
*/
public static String normalizeNoEndSeparator(final String fileName, final boolean unixSeparator) {
return doNormalize(fileName, toSeparator(unixSeparator), false);
}
/**
* Removes the extension from a fileName.
*
* This method returns the textual part of the file name before the last dot.
* There must be no directory separator after the dot.
*
* foo.txt --> foo
* .txt --> "" (empty string)
* a\b\c.jpg --> a\b\c
* /a/b/c.jpg --> /a/b/c
* a\b\c --> a\b\c
* a.b\c --> a.b\c
*
*
* The output will be the same irrespective of the machine that the code is running on.
*
* @param fileName the file name, null returns null
* @return the file name minus the extension
* @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
*/
public static String removeExtension(final String fileName) {
if (fileName == null) {
return null;
}
requireNonNullChars(fileName);
final int index = indexOfExtension(fileName);
if (index == NOT_FOUND) {
return fileName;
}
return fileName.substring(0, index);
}
/**
* Checks the input for null characters ({@code U+0000}), a sign of unsanitized data being passed to file level functions.
*
* This may be used to defend against poison byte attacks.
*
* @param path the path to check
* @return The input
* @throws IllegalArgumentException if path contains the null character ({@code U+0000})
*/
private static String requireNonNullChars(final String path) {
if (path.indexOf(0) >= 0) {
throw new IllegalArgumentException(
"Null character present in file/path name. There are no known legitimate use cases for such data, but several injection attacks may use it");
}
return path;
}
/**
* Converts all separators to the system separator.
*
* @param path the path to be changed, null ignored.
* @return the updated path.
*/
public static String separatorsToSystem(final String path) {
return FileSystem.getCurrent().normalizeSeparators(path);
}
/**
* Converts all separators to the UNIX separator of forward slash.
*
* @param path the path to be changed, null ignored.
* @return the new path.
*/
public static String separatorsToUnix(final String path) {
return FileSystem.LINUX.normalizeSeparators(path);
}
/**
* Converts all separators to the Windows separator of backslash.
*
* @param path the path to be changed, null ignored.
* @return the updated path.
*/
public static String separatorsToWindows(final String path) {
return FileSystem.WINDOWS.normalizeSeparators(path);
}
/**
* Splits a string into a number of tokens.
* The text is split by '?' and '*'.
* Where multiple '*' occur consecutively they are collapsed into a single '*'.
*
* @param text the text to split
* @return the array of tokens, never null
*/
static String[] splitOnTokens(final String text) {
// used by wildcardMatch
// package level so a unit test may run on this
if (text.indexOf('?') == NOT_FOUND && text.indexOf('*') == NOT_FOUND) {
return new String[] { text };
}
final char[] array = text.toCharArray();
final ArrayList list = new ArrayList<>();
final StringBuilder buffer = new StringBuilder();
char prevChar = 0;
for (final char ch : array) {
if (ch == '?' || ch == '*') {
if (buffer.length() != 0) {
list.add(buffer.toString());
buffer.setLength(0);
}
if (ch == '?') {
list.add("?");
} else if (prevChar != '*') {// ch == '*' here; check if previous char was '*'
list.add("*");
}
} else {
buffer.append(ch);
}
prevChar = ch;
}
if (buffer.length() != 0) {
list.add(buffer.toString());
}
return list.toArray(EMPTY_STRING_ARRAY);
}
/**
* Returns '/' if given true, '\\' otherwise.
*
* @param unixSeparator which separator to return.
* @return '/' if given true, '\\' otherwise.
*/
private static char toSeparator(final boolean unixSeparator) {
return unixSeparator ? UNIX_NAME_SEPARATOR : WINDOWS_NAME_SEPARATOR;
}
/**
* Checks a fileName to see if it matches the specified wildcard matcher,
* always testing case-sensitive.
*
* The wildcard matcher uses the characters '?' and '*' to represent a
* single or multiple (zero or more) wildcard characters.
* This is the same as often found on DOS/Unix command lines.
* The check is case-sensitive always.
*
* wildcardMatch("c.txt", "*.txt") --> true
* wildcardMatch("c.txt", "*.jpg") --> false
* wildcardMatch("a/b/c.txt", "a/b/*") --> true
* wildcardMatch("c.txt", "*.???") --> true
* wildcardMatch("c.txt", "*.????") --> false
*
* N.B. the sequence "*?" does not work properly at present in match strings.
*
* @param fileName the file name to match on
* @param wildcardMatcher the wildcard string to match against
* @return true if the file name matches the wildcard string
* @see IOCase#SENSITIVE
*/
public static boolean wildcardMatch(final String fileName, final String wildcardMatcher) {
return wildcardMatch(fileName, wildcardMatcher, IOCase.SENSITIVE);
}
/**
* Checks a fileName to see if it matches the specified wildcard matcher
* allowing control over case-sensitivity.
*
* The wildcard matcher uses the characters '?' and '*' to represent a
* single or multiple (zero or more) wildcard characters.
* N.B. the sequence "*?" does not work properly at present in match strings.
*
* @param fileName the file name to match on
* @param wildcardMatcher the wildcard string to match against
* @param ioCase what case sensitivity rule to use, null means case-sensitive
* @return true if the file name matches the wildcard string
* @since 1.3
*/
public static boolean wildcardMatch(final String fileName, final String wildcardMatcher, IOCase ioCase) {
if (fileName == null && wildcardMatcher == null) {
return true;
}
if (fileName == null || wildcardMatcher == null) {
return false;
}
ioCase = IOCase.value(ioCase, IOCase.SENSITIVE);
final String[] wcs = splitOnTokens(wildcardMatcher);
boolean anyChars = false;
int textIdx = 0;
int wcsIdx = 0;
final Deque backtrack = new ArrayDeque<>(wcs.length);
// loop around a backtrack stack, to handle complex * matching
do {
if (!backtrack.isEmpty()) {
final int[] array = backtrack.pop();
wcsIdx = array[0];
textIdx = array[1];
anyChars = true;
}
// loop whilst tokens and text left to process
while (wcsIdx < wcs.length) {
if (wcs[wcsIdx].equals("?")) {
// ? so move to next text char
textIdx++;
if (textIdx > fileName.length()) {
break;
}
anyChars = false;
} else if (wcs[wcsIdx].equals("*")) {
// set any chars status
anyChars = true;
if (wcsIdx == wcs.length - 1) {
textIdx = fileName.length();
}
} else {
// matching text token
if (anyChars) {
// any chars then try to locate text token
textIdx = ioCase.checkIndexOf(fileName, textIdx, wcs[wcsIdx]);
if (textIdx == NOT_FOUND) {
// token not found
break;
}
final int repeat = ioCase.checkIndexOf(fileName, textIdx + 1, wcs[wcsIdx]);
if (repeat >= 0) {
backtrack.push(new int[] {wcsIdx, repeat});
}
} else if (!ioCase.checkRegionMatches(fileName, textIdx, wcs[wcsIdx])) {
// matching from current position
// couldn't match token
break;
}
// matched text token, move text index to end of matched token
textIdx += wcs[wcsIdx].length();
anyChars = false;
}
wcsIdx++;
}
// full match
if (wcsIdx == wcs.length && textIdx == fileName.length()) {
return true;
}
} while (!backtrack.isEmpty());
return false;
}
/**
* Checks a fileName to see if it matches the specified wildcard matcher
* using the case rules of the system.
*
* The wildcard matcher uses the characters '?' and '*' to represent a
* single or multiple (zero or more) wildcard characters.
* This is the same as often found on DOS/Unix command lines.
* The check is case-sensitive on UNIX and case-insensitive on Windows.
*
* wildcardMatch("c.txt", "*.txt") --> true
* wildcardMatch("c.txt", "*.jpg") --> false
* wildcardMatch("a/b/c.txt", "a/b/*") --> true
* wildcardMatch("c.txt", "*.???") --> true
* wildcardMatch("c.txt", "*.????") --> false
*
* N.B. the sequence "*?" does not work properly at present in match strings.
*
* @param fileName the file name to match on
* @param wildcardMatcher the wildcard string to match against
* @return true if the file name matches the wildcard string
* @see IOCase#SYSTEM
*/
public static boolean wildcardMatchOnSystem(final String fileName, final String wildcardMatcher) {
return wildcardMatch(fileName, wildcardMatcher, IOCase.SYSTEM);
}
/**
* Instances should NOT be constructed in standard programming.
*
* @deprecated TODO Make private in 3.0.
*/
@Deprecated
public FilenameUtils() {
// empty
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/HexDump.java 0100644 0000000 0000000 00000021554 14603604450 025761 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.nio.charset.Charset;
import java.util.Objects;
import org.apache.commons.io.output.CloseShieldOutputStream;
/**
* Dumps data in hexadecimal format.
*
* Provides a single function to take an array of bytes and display it
* in hexadecimal form.
*
*
* Provenance: POI.
*
*/
public class HexDump {
/**
* The line-separator (initializes to "line.separator" system property).
*
* @deprecated Use {@link System#lineSeparator()}.
*/
@Deprecated
public static final String EOL = System.lineSeparator();
private static final char[] HEX_CODES =
{
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F'
};
private static final int[] SHIFTS =
{
28, 24, 20, 16, 12, 8, 4, 0
};
/**
* Dumps an array of bytes to an Appendable. The output is formatted
* for human inspection, with a hexadecimal offset followed by the
* hexadecimal values of the next 16 bytes of data and the printable ASCII
* characters (if any) that those bytes represent printed per each line
* of output.
*
* @param data the byte array to be dumped
* @param appendable the Appendable to which the data is to be written
*
* @throws IOException is thrown if anything goes wrong writing
* the data to appendable
* @throws NullPointerException if the output appendable is null
*
* @since 2.12.0
*/
public static void dump(final byte[] data, final Appendable appendable)
throws IOException {
dump(data, 0, appendable, 0, data.length);
}
/**
* Dumps an array of bytes to an Appendable. The output is formatted
* for human inspection, with a hexadecimal offset followed by the
* hexadecimal values of the next 16 bytes of data and the printable ASCII
* characters (if any) that those bytes represent printed per each line
* of output.
*
* The offset argument specifies the start offset of the data array
* within a larger entity like a file or an incoming stream. For example,
* if the data array contains the third kibibyte of a file, then the
* offset argument should be set to 2048. The offset value printed
* at the beginning of each line indicates where in that larger entity
* the first byte on that line is located.
*
*
* @param data the byte array to be dumped
* @param offset offset of the byte array within a larger entity
* @param appendable the Appendable to which the data is to be written
* @param index initial index into the byte array
* @param length number of bytes to dump from the array
*
* @throws IOException is thrown if anything goes wrong writing
* the data to appendable
* @throws ArrayIndexOutOfBoundsException if the index or length is
* outside the data array's bounds
* @throws NullPointerException if the output appendable is null
*
* @since 2.12.0
*/
public static void dump(final byte[] data, final long offset,
final Appendable appendable, final int index,
final int length)
throws IOException, ArrayIndexOutOfBoundsException {
Objects.requireNonNull(appendable, "appendable");
if (index < 0 || index >= data.length) {
throw new ArrayIndexOutOfBoundsException(
"illegal index: " + index + " into array of length "
+ data.length);
}
long display_offset = offset + index;
final StringBuilder buffer = new StringBuilder(74);
// TODO Use Objects.checkFromIndexSize(index, length, data.length) when upgrading to JDK9
if (length < 0 || index + length > data.length) {
throw new ArrayIndexOutOfBoundsException(String.format("Range [%s, % 16) {
chars_read = 16;
}
dump(buffer, display_offset).append(' ');
for (int k = 0; k < 16; k++) {
if (k < chars_read) {
dump(buffer, data[k + j]);
} else {
buffer.append(" ");
}
buffer.append(' ');
}
for (int k = 0; k < chars_read; k++) {
if (data[k + j] >= ' ' && data[k + j] < 127) {
buffer.append((char) data[k + j]);
} else {
buffer.append('.');
}
}
buffer.append(System.lineSeparator());
appendable.append(buffer);
buffer.setLength(0);
display_offset += chars_read;
}
}
/**
* Dumps an array of bytes to an OutputStream. The output is formatted
* for human inspection, with a hexadecimal offset followed by the
* hexadecimal values of the next 16 bytes of data and the printable ASCII
* characters (if any) that those bytes represent printed per each line
* of output.
*
* The offset argument specifies the start offset of the data array
* within a larger entity like a file or an incoming stream. For example,
* if the data array contains the third kibibyte of a file, then the
* offset argument should be set to 2048. The offset value printed
* at the beginning of each line indicates where in that larger entity
* the first byte on that line is located.
*
*
* All bytes between the given index (inclusive) and the end of the
* data array are dumped.
*
*
* @param data the byte array to be dumped
* @param offset offset of the byte array within a larger entity
* @param stream the OutputStream to which the data is to be
* written
* @param index initial index into the byte array
*
* @throws IOException is thrown if anything goes wrong writing
* the data to stream
* @throws ArrayIndexOutOfBoundsException if the index is
* outside the data array's bounds
* @throws NullPointerException if the output stream is null
*/
@SuppressWarnings("resource") // Caller closes stream
public static void dump(final byte[] data, final long offset,
final OutputStream stream, final int index)
throws IOException, ArrayIndexOutOfBoundsException {
Objects.requireNonNull(stream, "stream");
try (OutputStreamWriter out = new OutputStreamWriter(CloseShieldOutputStream.wrap(stream), Charset.defaultCharset())) {
dump(data, offset, out, index, data.length - index);
}
}
/**
* Dumps a byte value into a StringBuilder.
*
* @param _cbuffer the StringBuilder to dump the value in
* @param value the byte value to be dumped
* @return StringBuilder containing the dumped value.
*/
private static StringBuilder dump(final StringBuilder _cbuffer, final byte value) {
for (int j = 0; j < 2; j++) {
_cbuffer.append(HEX_CODES[value >> SHIFTS[j + 6] & 15]);
}
return _cbuffer;
}
/**
* Dumps a long value into a StringBuilder.
*
* @param _lbuffer the StringBuilder to dump the value in
* @param value the long value to be dumped
* @return StringBuilder containing the dumped value.
*/
private static StringBuilder dump(final StringBuilder _lbuffer, final long value) {
for (int j = 0; j < 8; j++) {
_lbuffer
.append(HEX_CODES[(int) (value >> SHIFTS[j]) & 15]);
}
return _lbuffer;
}
/**
* Instances should NOT be constructed in standard programming.
*/
public HexDump() {
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/IO.java 0100644 0000000 0000000 00000002044 14603604450 024707 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
/**
* Component-wide operations on Apache Commons IO.
*/
final class IO {
/**
* Clears any state, throughout Apache Commons IO. Handy for tests.
*/
static void clear() {
IOUtils.clear();
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/IOCase.java 0100644 0000000 0000000 00000022051 14603604450 025503 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.util.Objects;
import java.util.stream.Stream;
/**
* Enumeration of IO case sensitivity.
*
* Different filing systems have different rules for case-sensitivity.
* Windows is case-insensitive, UNIX is case-sensitive.
*
*
* This class captures that difference, providing an enumeration to
* control how file name comparisons should be performed. It also provides
* methods that use the enumeration to perform comparisons.
*
*
* Wherever possible, you should use the {@code check} methods in this
* class to compare file names.
*
*
* @since 1.3
*/
public enum IOCase {
/**
* The constant for case-sensitive regardless of operating system.
*/
SENSITIVE("Sensitive", true),
/**
* The constant for case-insensitive regardless of operating system.
*/
INSENSITIVE("Insensitive", false),
/**
* The constant for case sensitivity determined by the current operating system.
* Windows is case-insensitive when comparing file names, UNIX is case-sensitive.
*
* Note: This only caters for Windows and Unix. Other operating
* systems (e.g. OSX and OpenVMS) are treated as case-sensitive if they use the
* UNIX file separator and case-insensitive if they use the Windows file separator
* (see {@link java.io.File#separatorChar}).
*
*
* If you serialize this constant on Windows, and deserialize on Unix, or vice
* versa, then the value of the case-sensitivity flag will change.
*
*/
SYSTEM("System", FileSystem.getCurrent().isCaseSensitive());
/** Serialization version. */
private static final long serialVersionUID = -6343169151696340687L;
/**
* Looks up an IOCase by name.
*
* @param name the name to find
* @return the IOCase object
* @throws IllegalArgumentException if the name is invalid
*/
public static IOCase forName(final String name) {
return Stream.of(IOCase.values()).filter(ioCase -> ioCase.getName().equals(name)).findFirst()
.orElseThrow(() -> new IllegalArgumentException("Illegal IOCase name: " + name));
}
/**
* Tests for cases sensitivity in a null-safe manner.
*
* @param ioCase an IOCase.
* @return true if the input is non-null and {@link #isCaseSensitive()}.
* @since 2.10.0
*/
public static boolean isCaseSensitive(final IOCase ioCase) {
return ioCase != null && ioCase.isCaseSensitive();
}
/**
* Returns the given value if not-null, the defaultValue if null.
*
* @param value the value to test.
* @param defaultValue the default value.
* @return the given value if not-null, the defaultValue if null.
* @since 2.12.0
*/
public static IOCase value(final IOCase value, final IOCase defaultValue) {
return value != null ? value : defaultValue;
}
/** The enumeration name. */
private final String name;
/** The sensitivity flag. */
private final transient boolean sensitive;
/**
* Constructs a new instance.
*
* @param name the name.
* @param sensitive the sensitivity.
*/
IOCase(final String name, final boolean sensitive) {
this.name = name;
this.sensitive = sensitive;
}
/**
* Compares two strings using the case-sensitivity rule.
*
* This method mimics {@link String#compareTo} but takes case-sensitivity
* into account.
*
*
* @param str1 the first string to compare, not null.
* @param str2 the second string to compare, not null.
* @return true if equal using the case rules.
* @throws NullPointerException if either string is null.
*/
public int checkCompareTo(final String str1, final String str2) {
Objects.requireNonNull(str1, "str1");
Objects.requireNonNull(str2, "str2");
return sensitive ? str1.compareTo(str2) : str1.compareToIgnoreCase(str2);
}
/**
* Checks if one string ends with another using the case-sensitivity rule.
*
* This method mimics {@link String#endsWith} but takes case-sensitivity
* into account.
*
*
* @param str the string to check.
* @param end the end to compare against.
* @return true if equal using the case rules, false if either input is null.
*/
public boolean checkEndsWith(final String str, final String end) {
if (str == null || end == null) {
return false;
}
final int endLen = end.length();
return str.regionMatches(!sensitive, str.length() - endLen, end, 0, endLen);
}
/**
* Compares two strings using the case-sensitivity rule.
*
* This method mimics {@link String#equals} but takes case-sensitivity
* into account.
*
*
* @param str1 the first string to compare.
* @param str2 the second string to compare.
* @return true if equal using the case rules.
*/
public boolean checkEquals(final String str1, final String str2) {
return str1 == str2 || str1 != null && (sensitive ? str1.equals(str2) : str1.equalsIgnoreCase(str2));
}
/**
* Checks if one string contains another starting at a specific index using the
* case-sensitivity rule.
*
* This method mimics parts of {@link String#indexOf(String, int)}
* but takes case-sensitivity into account.
*
*
* @param str the string to check.
* @param strStartIndex the index to start at in str.
* @param search the start to search for.
* @return the first index of the search String,
* -1 if no match or {@code null} string input.
* @since 2.0
*/
public int checkIndexOf(final String str, final int strStartIndex, final String search) {
if (str != null && search != null) {
final int endIndex = str.length() - search.length();
if (endIndex >= strStartIndex) {
for (int i = strStartIndex; i <= endIndex; i++) {
if (checkRegionMatches(str, i, search)) {
return i;
}
}
}
}
return -1;
}
/**
* Checks if one string contains another at a specific index using the case-sensitivity rule.
*
* This method mimics parts of {@link String#regionMatches(boolean, int, String, int, int)}
* but takes case-sensitivity into account.
*
*
* @param str the string to check.
* @param strStartIndex the index to start at in str.
* @param search the start to search for,.
* @return true if equal using the case rules.
*/
public boolean checkRegionMatches(final String str, final int strStartIndex, final String search) {
return str != null && search != null && str.regionMatches(!sensitive, strStartIndex, search, 0, search.length());
}
/**
* Checks if one string starts with another using the case-sensitivity rule.
*
* This method mimics {@link String#startsWith(String)} but takes case-sensitivity
* into account.
*
*
* @param str the string to check.
* @param start the start to compare against.
* @return true if equal using the case rules, false if either input is null.
*/
public boolean checkStartsWith(final String str, final String start) {
return str != null && start != null && str.regionMatches(!sensitive, 0, start, 0, start.length());
}
/**
* Gets the name of the constant.
*
* @return the name of the constant
*/
public String getName() {
return name;
}
/**
* Does the object represent case-sensitive comparison.
*
* @return true if case-sensitive.
*/
public boolean isCaseSensitive() {
return sensitive;
}
/**
* Replaces the enumeration from the stream with a real one.
* This ensures that the correct flag is set for SYSTEM.
*
* @return the resolved object.
*/
private Object readResolve() {
return forName(name);
}
/**
* Gets a string describing the sensitivity.
*
* @return a string describing the sensitivity.
*/
@Override
public String toString() {
return name;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/IOExceptionList.java 0100644 0000000 0000000 00000011157 14603604450 027427 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
/**
* An IOException based on a list of Throwable causes.
*
* The first exception in the list is used as this exception's cause and is accessible with the usual
* {@link #getCause()} while the complete list is accessible with {@link #getCauseList()}.
*
*
* @since 2.7
*/
public class IOExceptionList extends IOException implements Iterable {
private static final long serialVersionUID = 1L;
/**
* Throws this exception if the list is not null or empty.
*
* @param causeList The list to test.
* @param message The detail message, see {@link #getMessage()}.
* @throws IOExceptionList if the list is not null or empty.
* @since 2.12.0
*/
public static void checkEmpty(final List causeList, final Object message) throws IOExceptionList {
if (!isEmpty(causeList)) {
throw new IOExceptionList(Objects.toString(message, null), causeList);
}
}
private static boolean isEmpty(final List causeList) {
return size(causeList) == 0;
}
private static int size(final List causeList) {
return causeList != null ? causeList.size() : 0;
}
private static String toMessage(final List causeList) {
return String.format("%,d exception(s): %s", size(causeList), causeList);
}
/**
* List of causes.
*/
private final List causeList;
/**
* Constructs a new exception caused by a list of exceptions.
*
* @param causeList a list of cause exceptions.
*/
public IOExceptionList(final List causeList) {
this(toMessage(causeList), causeList);
}
/**
* Constructs a new exception caused by a list of exceptions.
*
* @param message The detail message, see {@link #getMessage()}.
* @param causeList a list of cause exceptions.
* @since 2.9.0
*/
public IOExceptionList(final String message, final List causeList) {
super(message != null ? message : toMessage(causeList), isEmpty(causeList) ? null : causeList.get(0));
this.causeList = causeList == null ? Collections.emptyList() : causeList;
}
/**
* Gets the cause exception at the given index.
*
* @param type of exception to return.
* @param index index in the cause list.
* @return The list of causes.
*/
public T getCause(final int index) {
return (T) causeList.get(index);
}
/**
* Gets the cause exception at the given index.
*
* @param type of exception to return.
* @param index index in the cause list.
* @param clazz type of exception to return.
* @return The list of causes.
*/
public T getCause(final int index, final Class clazz) {
return clazz.cast(getCause(index));
}
/**
* Gets the cause list.
*
* @param type of exception to return.
* @return The list of causes.
*/
public List getCauseList() {
return (List) new ArrayList<>(causeList);
}
/**
* Works around Throwable and Generics, may fail at runtime depending on the argument value.
*
* @param type of exception to return.
* @param clazz the target type
* @return The list of causes.
*/
public List getCauseList(final Class clazz) {
return (List) new ArrayList<>(causeList);
}
@Override
public Iterator iterator() {
return getCauseList().iterator();
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/IOExceptionWithCause.java 0100644 0000000 0000000 00000004354 14603604450 030411 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.IOException;
/**
* Subclasses IOException with the {@link Throwable} constructors missing before Java 6.
*
* @since 1.4
* @deprecated (since 2.5) use {@link IOException} instead
*/
@Deprecated
public class IOExceptionWithCause extends IOException {
/**
* Defines the serial version UID.
*/
private static final long serialVersionUID = 1L;
/**
* Constructs a new instance with the given message and cause.
*
* As specified in {@link Throwable}, the message in the given {@code cause} is not used in this instance's
* message.
*
*
* @param message
* the message (see {@link #getMessage()})
* @param cause
* the cause (see {@link #getCause()}). A {@code null} value is allowed.
*/
public IOExceptionWithCause(final String message, final Throwable cause) {
super(message, cause);
}
/**
* Constructs a new instance with the given cause.
*
* The message is set to {@code cause==null ? null : cause.toString()}, which by default contains the class
* and message of {@code cause}. This constructor is useful for call sites that just wrap another throwable.
*
*
* @param cause
* the cause (see {@link #getCause()}). A {@code null} value is allowed.
*/
public IOExceptionWithCause(final Throwable cause) {
super(cause);
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/IOIndexedException.java 0100644 0000000 0000000 00000004155 14603604450 030074 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.IOException;
/**
* A IOException associated with a source index.
*
* @since 2.7
*/
public class IOIndexedException extends IOException {
private static final long serialVersionUID = 1L;
/**
* Converts input to a suitable String for exception message.
*
* @param index An index into a source collection.
* @param cause A cause.
* @return A message.
*/
protected static String toMessage(final int index, final Throwable cause) {
// Letting index be any int
final String unspecified = "Null";
final String name = cause == null ? unspecified : cause.getClass().getSimpleName();
final String msg = cause == null ? unspecified : cause.getMessage();
return String.format("%s #%,d: %s", name, index, msg);
}
/**
* Index.
*/
private final int index;
/**
* Constructs a new exception.
*
* @param index index of this exception.
* @param cause cause exceptions.
*/
public IOIndexedException(final int index, final Throwable cause) {
super(toMessage(index, cause), cause);
this.index = index;
}
/**
* The index of this exception.
*
* @return index of this exception.
*/
public int getIndex() {
return index;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/IOUtils.java 0100644 0000000 0000000 00000450736 14603604450 025747 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.CharArrayWriter;
import java.io.Closeable;
import java.io.EOFException;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.UncheckedIOException;
import java.io.Writer;
import java.net.HttpURLConnection;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URI;
import java.net.URL;
import java.net.URLConnection;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.Selector;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.zip.InflaterInputStream;
import org.apache.commons.io.function.IOConsumer;
import org.apache.commons.io.function.IOSupplier;
import org.apache.commons.io.function.IOTriFunction;
import org.apache.commons.io.input.QueueInputStream;
import org.apache.commons.io.output.AppendableWriter;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.io.output.NullOutputStream;
import org.apache.commons.io.output.NullWriter;
import org.apache.commons.io.output.StringBuilderWriter;
import org.apache.commons.io.output.ThresholdingOutputStream;
import org.apache.commons.io.output.UnsynchronizedByteArrayOutputStream;
/**
* General IO stream manipulation utilities.
*
* This class provides static utility methods for input/output operations.
*
*
* - closeQuietly - these methods close a stream ignoring nulls and exceptions
*
- toXxx/read - these methods read data from a stream
*
- write - these methods write data to a stream
*
- copy - these methods copy all the data from one stream to another
*
- contentEquals - these methods compare the content of two streams
*
*
* The byte-to-char methods and char-to-byte methods involve a conversion step.
* Two methods are provided in each case, one that uses the platform default
* encoding and the other which allows you to specify an encoding. You are
* encouraged to always specify an encoding because relying on the platform
* default can lead to unexpected results, for example when moving from
* development to production.
*
*
* All the methods in this class that read a stream are buffered internally.
* This means that there is no cause to use a {@link BufferedInputStream}
* or {@link BufferedReader}. The default buffer size of 4K has been shown
* to be efficient in tests.
*
*
* The various copy methods all delegate the actual copying to one of the following methods:
*
*
* - {@link #copyLarge(InputStream, OutputStream, byte[])}
* - {@link #copyLarge(InputStream, OutputStream, long, long, byte[])}
* - {@link #copyLarge(Reader, Writer, char[])}
* - {@link #copyLarge(Reader, Writer, long, long, char[])}
*
* For example, {@link #copy(InputStream, OutputStream)} calls {@link #copyLarge(InputStream, OutputStream)}
* which calls {@link #copy(InputStream, OutputStream, int)} which creates the buffer and calls
* {@link #copyLarge(InputStream, OutputStream, byte[])}.
*
* Applications can re-use buffers by using the underlying methods directly.
* This may improve performance for applications that need to do a lot of copying.
*
*
* Wherever possible, the methods in this class do not flush or close
* the stream. This is to avoid making non-portable assumptions about the
* streams' origin and further use. Thus the caller is still responsible for
* closing streams after use.
*
*
* Provenance: Excalibur.
*
*/
public class IOUtils {
// NOTE: This class is focused on InputStream, OutputStream, Reader and
// Writer. Each method should take at least one of these as a parameter,
// or return one of them.
/**
* CR char.
*
* @since 2.9.0
*/
public static final int CR = '\r';
/**
* The default buffer size ({@value}) to use in copy methods.
*/
public static final int DEFAULT_BUFFER_SIZE = 8192;
/**
* The system directory separator character.
*/
public static final char DIR_SEPARATOR = File.separatorChar;
/**
* The UNIX directory separator character.
*/
public static final char DIR_SEPARATOR_UNIX = '/';
/**
* The Windows directory separator character.
*/
public static final char DIR_SEPARATOR_WINDOWS = '\\';
/**
* A singleton empty byte array.
*
* @since 2.9.0
*/
public static final byte[] EMPTY_BYTE_ARRAY = {};
/**
* Represents the end-of-file (or stream).
* @since 2.5 (made public)
*/
public static final int EOF = -1;
/**
* LF char.
*
* @since 2.9.0
*/
public static final int LF = '\n';
/**
* The system line separator string.
*
* @deprecated Use {@link System#lineSeparator()}.
*/
@Deprecated
public static final String LINE_SEPARATOR = System.lineSeparator();
/**
* The UNIX line separator string.
*
* @see StandardLineSeparator#LF
*/
public static final String LINE_SEPARATOR_UNIX = StandardLineSeparator.LF.getString();
/**
* The Windows line separator string.
*
* @see StandardLineSeparator#CRLF
*/
public static final String LINE_SEPARATOR_WINDOWS = StandardLineSeparator.CRLF.getString();
/**
* Internal byte array buffer, intended for both reading and writing.
*/
private static final ThreadLocal SCRATCH_BYTE_BUFFER_RW = ThreadLocal.withInitial(IOUtils::byteArray);
/**
* Internal byte array buffer, intended for write only operations.
*/
private static final byte[] SCRATCH_BYTE_BUFFER_WO = byteArray();
/**
* Internal char array buffer, intended for both reading and writing.
*/
private static final ThreadLocal SCRATCH_CHAR_BUFFER_RW = ThreadLocal.withInitial(IOUtils::charArray);
/**
* Internal char array buffer, intended for write only operations.
*/
private static final char[] SCRATCH_CHAR_BUFFER_WO = charArray();
/**
* Returns the given InputStream if it is already a {@link BufferedInputStream}, otherwise creates a
* BufferedInputStream from the given InputStream.
*
* @param inputStream the InputStream to wrap or return (not null)
* @return the given InputStream or a new {@link BufferedInputStream} for the given InputStream
* @throws NullPointerException if the input parameter is null
* @since 2.5
*/
@SuppressWarnings("resource") // parameter null check
public static BufferedInputStream buffer(final InputStream inputStream) {
// reject null early on rather than waiting for IO operation to fail
// not checked by BufferedInputStream
Objects.requireNonNull(inputStream, "inputStream");
return inputStream instanceof BufferedInputStream ?
(BufferedInputStream) inputStream : new BufferedInputStream(inputStream);
}
/**
* Returns the given InputStream if it is already a {@link BufferedInputStream}, otherwise creates a
* BufferedInputStream from the given InputStream.
*
* @param inputStream the InputStream to wrap or return (not null)
* @param size the buffer size, if a new BufferedInputStream is created.
* @return the given InputStream or a new {@link BufferedInputStream} for the given InputStream
* @throws NullPointerException if the input parameter is null
* @since 2.5
*/
@SuppressWarnings("resource") // parameter null check
public static BufferedInputStream buffer(final InputStream inputStream, final int size) {
// reject null early on rather than waiting for IO operation to fail
// not checked by BufferedInputStream
Objects.requireNonNull(inputStream, "inputStream");
return inputStream instanceof BufferedInputStream ?
(BufferedInputStream) inputStream : new BufferedInputStream(inputStream, size);
}
/**
* Returns the given OutputStream if it is already a {@link BufferedOutputStream}, otherwise creates a
* BufferedOutputStream from the given OutputStream.
*
* @param outputStream the OutputStream to wrap or return (not null)
* @return the given OutputStream or a new {@link BufferedOutputStream} for the given OutputStream
* @throws NullPointerException if the input parameter is null
* @since 2.5
*/
@SuppressWarnings("resource") // parameter null check
public static BufferedOutputStream buffer(final OutputStream outputStream) {
// reject null early on rather than waiting for IO operation to fail
// not checked by BufferedInputStream
Objects.requireNonNull(outputStream, "outputStream");
return outputStream instanceof BufferedOutputStream ?
(BufferedOutputStream) outputStream : new BufferedOutputStream(outputStream);
}
/**
* Returns the given OutputStream if it is already a {@link BufferedOutputStream}, otherwise creates a
* BufferedOutputStream from the given OutputStream.
*
* @param outputStream the OutputStream to wrap or return (not null)
* @param size the buffer size, if a new BufferedOutputStream is created.
* @return the given OutputStream or a new {@link BufferedOutputStream} for the given OutputStream
* @throws NullPointerException if the input parameter is null
* @since 2.5
*/
@SuppressWarnings("resource") // parameter null check
public static BufferedOutputStream buffer(final OutputStream outputStream, final int size) {
// reject null early on rather than waiting for IO operation to fail
// not checked by BufferedInputStream
Objects.requireNonNull(outputStream, "outputStream");
return outputStream instanceof BufferedOutputStream ?
(BufferedOutputStream) outputStream : new BufferedOutputStream(outputStream, size);
}
/**
* Returns the given reader if it is already a {@link BufferedReader}, otherwise creates a BufferedReader from
* the given reader.
*
* @param reader the reader to wrap or return (not null)
* @return the given reader or a new {@link BufferedReader} for the given reader
* @throws NullPointerException if the input parameter is null
* @since 2.5
*/
public static BufferedReader buffer(final Reader reader) {
return reader instanceof BufferedReader ? (BufferedReader) reader : new BufferedReader(reader);
}
/**
* Returns the given reader if it is already a {@link BufferedReader}, otherwise creates a BufferedReader from the
* given reader.
*
* @param reader the reader to wrap or return (not null)
* @param size the buffer size, if a new BufferedReader is created.
* @return the given reader or a new {@link BufferedReader} for the given reader
* @throws NullPointerException if the input parameter is null
* @since 2.5
*/
public static BufferedReader buffer(final Reader reader, final int size) {
return reader instanceof BufferedReader ? (BufferedReader) reader : new BufferedReader(reader, size);
}
/**
* Returns the given Writer if it is already a {@link BufferedWriter}, otherwise creates a BufferedWriter from the
* given Writer.
*
* @param writer the Writer to wrap or return (not null)
* @return the given Writer or a new {@link BufferedWriter} for the given Writer
* @throws NullPointerException if the input parameter is null
* @since 2.5
*/
public static BufferedWriter buffer(final Writer writer) {
return writer instanceof BufferedWriter ? (BufferedWriter) writer : new BufferedWriter(writer);
}
/**
* Returns the given Writer if it is already a {@link BufferedWriter}, otherwise creates a BufferedWriter from the
* given Writer.
*
* @param writer the Writer to wrap or return (not null)
* @param size the buffer size, if a new BufferedWriter is created.
* @return the given Writer or a new {@link BufferedWriter} for the given Writer
* @throws NullPointerException if the input parameter is null
* @since 2.5
*/
public static BufferedWriter buffer(final Writer writer, final int size) {
return writer instanceof BufferedWriter ? (BufferedWriter) writer : new BufferedWriter(writer, size);
}
/**
* Returns a new byte array of size {@link #DEFAULT_BUFFER_SIZE}.
*
* @return a new byte array of size {@link #DEFAULT_BUFFER_SIZE}.
* @since 2.9.0
*/
public static byte[] byteArray() {
return byteArray(DEFAULT_BUFFER_SIZE);
}
/**
* Returns a new byte array of the given size.
*
* TODO Consider guarding or warning against large allocations...
*
* @param size array size.
* @return a new byte array of the given size.
* @throws NegativeArraySizeException if the size is negative.
* @since 2.9.0
*/
public static byte[] byteArray(final int size) {
return new byte[size];
}
/**
* Returns a new char array of size {@link #DEFAULT_BUFFER_SIZE}.
*
* @return a new char array of size {@link #DEFAULT_BUFFER_SIZE}.
* @since 2.9.0
*/
private static char[] charArray() {
return charArray(DEFAULT_BUFFER_SIZE);
}
/**
* Returns a new char array of the given size.
*
* TODO Consider guarding or warning against large allocations...
*
* @param size array size.
* @return a new char array of the given size.
* @since 2.9.0
*/
private static char[] charArray(final int size) {
return new char[size];
}
/**
* Clears any state.
*
* - Removes the current thread's value for thread-local variables.
* - Sets static scratch arrays to 0s.
*
* @see IO#clear()
*/
static void clear() {
SCRATCH_BYTE_BUFFER_RW.remove();
SCRATCH_CHAR_BUFFER_RW.remove();
Arrays.fill(SCRATCH_BYTE_BUFFER_WO, (byte) 0);
Arrays.fill(SCRATCH_CHAR_BUFFER_WO, (char) 0);
}
/**
* Closes the given {@link Closeable} as a null-safe operation.
*
* @param closeable The resource to close, may be null.
* @throws IOException if an I/O error occurs.
* @since 2.7
*/
public static void close(final Closeable closeable) throws IOException {
if (closeable != null) {
closeable.close();
}
}
/**
* Closes the given {@link Closeable}s as null-safe operations.
*
* @param closeables The resource(s) to close, may be null.
* @throws IOExceptionList if an I/O error occurs.
* @since 2.8.0
*/
public static void close(final Closeable... closeables) throws IOExceptionList {
IOConsumer.forAll(IOUtils::close, closeables);
}
/**
* Closes the given {@link Closeable} as a null-safe operation.
*
* @param closeable The resource to close, may be null.
* @param consumer Consume the IOException thrown by {@link Closeable#close()}.
* @throws IOException if an I/O error occurs.
* @since 2.7
*/
public static void close(final Closeable closeable, final IOConsumer consumer) throws IOException {
if (closeable != null) {
try {
closeable.close();
} catch (final IOException e) {
if (consumer != null) {
consumer.accept(e);
}
}
}
}
/**
* Closes a URLConnection.
*
* @param conn the connection to close.
* @since 2.4
*/
public static void close(final URLConnection conn) {
if (conn instanceof HttpURLConnection) {
((HttpURLConnection) conn).disconnect();
}
}
/**
* Avoids the need to type cast.
*
* @param closeable the object to close, may be null
*/
private static void closeQ(final Closeable closeable) {
closeQuietly(closeable, null);
}
/**
* Closes a {@link Closeable} unconditionally.
*
*
* Equivalent to {@link Closeable#close()}, except any exceptions will be ignored. This is typically used in
* finally blocks.
*
* Example code:
*
*
* Closeable closeable = null;
* try {
* closeable = new FileReader("foo.txt");
* // process closeable
* closeable.close();
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(closeable);
* }
*
*
* Closing all streams:
*
*
* try {
* return IOUtils.copy(inputStream, outputStream);
* } finally {
* IOUtils.closeQuietly(inputStream);
* IOUtils.closeQuietly(outputStream);
* }
*
*
* Also consider using a try-with-resources statement where appropriate.
*
*
* @param closeable the objects to close, may be null or already closed
* @since 2.0
*
* @see Throwable#addSuppressed(Throwable)
*/
public static void closeQuietly(final Closeable closeable) {
closeQuietly(closeable, null);
}
/**
* Closes a {@link Closeable} unconditionally.
*
* Equivalent to {@link Closeable#close()}, except any exceptions will be ignored.
*
* This is typically used in finally blocks to ensure that the closeable is closed
* even if an Exception was thrown before the normal close statement was reached.
*
* It should not be used to replace the close statement(s)
* which should be present for the non-exceptional case.
*
* It is only intended to simplify tidying up where normal processing has already failed
* and reporting close failure as well is not necessary or useful.
*
* Example code:
*
*
* Closeable closeable = null;
* try {
* closeable = new FileReader("foo.txt");
* // processing using the closeable; may throw an Exception
* closeable.close(); // Normal close - exceptions not ignored
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(closeable); // In case normal close was skipped due to Exception
* }
*
*
* Closing all streams:
*
*
* try {
* return IOUtils.copy(inputStream, outputStream);
* } finally {
* IOUtils.closeQuietly(inputStream, outputStream);
* }
*
*
* Also consider using a try-with-resources statement where appropriate.
*
* @param closeables the objects to close, may be null or already closed
* @see #closeQuietly(Closeable)
* @since 2.5
* @see Throwable#addSuppressed(Throwable)
*/
public static void closeQuietly(final Closeable... closeables) {
if (closeables != null) {
closeQuietly(Arrays.stream(closeables));
}
}
/**
* Closes the given {@link Closeable} as a null-safe operation while consuming IOException by the given {@code consumer}.
*
* @param closeable The resource to close, may be null.
* @param consumer Consumes the IOException thrown by {@link Closeable#close()}.
* @since 2.7
*/
public static void closeQuietly(final Closeable closeable, final Consumer consumer) {
if (closeable != null) {
try {
closeable.close();
} catch (final IOException e) {
if (consumer != null) {
consumer.accept(e);
}
}
}
}
/**
* Closes an {@link InputStream} unconditionally.
*
* Equivalent to {@link InputStream#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
*
* Example code:
*
*
* byte[] data = new byte[1024];
* InputStream in = null;
* try {
* in = new FileInputStream("foo.txt");
* in.read(data);
* in.close(); //close errors are handled
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(in);
* }
*
*
* Also consider using a try-with-resources statement where appropriate.
*
*
* @param input the InputStream to close, may be null or already closed
* @see Throwable#addSuppressed(Throwable)
*/
public static void closeQuietly(final InputStream input) {
closeQ(input);
}
/**
* Closes an iterable of {@link Closeable} unconditionally.
*
* Equivalent calling {@link Closeable#close()} on each element, except any exceptions will be ignored.
*
*
* @param closeables the objects to close, may be null or already closed
* @see #closeQuietly(Closeable)
* @since 2.12.0
*/
public static void closeQuietly(final Iterable closeables) {
if (closeables != null) {
closeables.forEach(IOUtils::closeQuietly);
}
}
/**
* Closes an {@link OutputStream} unconditionally.
*
* Equivalent to {@link OutputStream#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
*
* Example code:
*
*
* byte[] data = "Hello, World".getBytes();
*
* OutputStream out = null;
* try {
* out = new FileOutputStream("foo.txt");
* out.write(data);
* out.close(); //close errors are handled
* } catch (IOException e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(out);
* }
*
*
* Also consider using a try-with-resources statement where appropriate.
*
*
* @param output the OutputStream to close, may be null or already closed
* @see Throwable#addSuppressed(Throwable)
*/
public static void closeQuietly(final OutputStream output) {
closeQ(output);
}
/**
* Closes an {@link Reader} unconditionally.
*
* Equivalent to {@link Reader#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
*
* Example code:
*
*
* char[] data = new char[1024];
* Reader in = null;
* try {
* in = new FileReader("foo.txt");
* in.read(data);
* in.close(); //close errors are handled
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(in);
* }
*
*
* Also consider using a try-with-resources statement where appropriate.
*
*
* @param reader the Reader to close, may be null or already closed
* @see Throwable#addSuppressed(Throwable)
*/
public static void closeQuietly(final Reader reader) {
closeQ(reader);
}
/**
* Closes a {@link Selector} unconditionally.
*
* Equivalent to {@link Selector#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
*
* Example code:
*
*
* Selector selector = null;
* try {
* selector = Selector.open();
* // process socket
*
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(selector);
* }
*
*
* Also consider using a try-with-resources statement where appropriate.
*
*
* @param selector the Selector to close, may be null or already closed
* @since 2.2
* @see Throwable#addSuppressed(Throwable)
*/
public static void closeQuietly(final Selector selector) {
closeQ(selector);
}
/**
* Closes a {@link ServerSocket} unconditionally.
*
* Equivalent to {@link ServerSocket#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
*
* Example code:
*
*
* ServerSocket socket = null;
* try {
* socket = new ServerSocket();
* // process socket
* socket.close();
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(socket);
* }
*
*
* Also consider using a try-with-resources statement where appropriate.
*
*
* @param serverSocket the ServerSocket to close, may be null or already closed
* @since 2.2
* @see Throwable#addSuppressed(Throwable)
*/
public static void closeQuietly(final ServerSocket serverSocket) {
closeQ(serverSocket);
}
/**
* Closes a {@link Socket} unconditionally.
*
* Equivalent to {@link Socket#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
*
* Example code:
*
*
* Socket socket = null;
* try {
* socket = new Socket("http://www.foo.com/", 80);
* // process socket
* socket.close();
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(socket);
* }
*
*
* Also consider using a try-with-resources statement where appropriate.
*
*
* @param socket the Socket to close, may be null or already closed
* @since 2.0
* @see Throwable#addSuppressed(Throwable)
*/
public static void closeQuietly(final Socket socket) {
closeQ(socket);
}
/**
* Closes a stream of {@link Closeable} unconditionally.
*
* Equivalent calling {@link Closeable#close()} on each element, except any exceptions will be ignored.
*
*
* @param closeables the objects to close, may be null or already closed
* @see #closeQuietly(Closeable)
* @since 2.12.0
*/
public static void closeQuietly(final Stream closeables) {
if (closeables != null) {
closeables.forEach(IOUtils::closeQuietly);
}
}
/**
* Closes an {@link Writer} unconditionally.
*
* Equivalent to {@link Writer#close()}, except any exceptions will be ignored.
* This is typically used in finally blocks.
*
*
* Example code:
*
*
* Writer out = null;
* try {
* out = new StringWriter();
* out.write("Hello World");
* out.close(); //close errors are handled
* } catch (Exception e) {
* // error handling
* } finally {
* IOUtils.closeQuietly(out);
* }
*
*
* Also consider using a try-with-resources statement where appropriate.
*
*
* @param writer the Writer to close, may be null or already closed
* @see Throwable#addSuppressed(Throwable)
*/
public static void closeQuietly(final Writer writer) {
closeQ(writer);
}
/**
* Consumes bytes from a {@link InputStream} and ignores them.
*
* The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
*
*
* @param input the {@link InputStream} to read.
* @return the number of bytes copied. or {@code 0} if {@code input is null}.
* @throws NullPointerException if the InputStream is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 2.8.0
*/
public static long consume(final InputStream input) throws IOException {
return copyLarge(input, NullOutputStream.INSTANCE);
}
/**
* Consumes characters from a {@link Reader} and ignores them.
*
* The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
*
*
* @param input the {@link Reader} to read.
* @return the number of bytes copied. or {@code 0} if {@code input is null}.
* @throws NullPointerException if the Reader is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 2.12.0
*/
public static long consume(final Reader input) throws IOException {
return copyLarge(input, NullWriter.INSTANCE);
}
/**
* Compares the contents of two Streams to determine if they are equal or
* not.
*
* This method buffers the input internally using
* {@link BufferedInputStream} if they are not already buffered.
*
*
* @param input1 the first stream
* @param input2 the second stream
* @return true if the content of the streams are equal or they both don't
* exist, false otherwise
* @throws IOException if an I/O error occurs
*/
public static boolean contentEquals(final InputStream input1, final InputStream input2) throws IOException {
// Before making any changes, please test with
// org.apache.commons.io.jmh.IOUtilsContentEqualsInputStreamsBenchmark
if (input1 == input2) {
return true;
}
if (input1 == null || input2 == null) {
return false;
}
// reuse one
final byte[] array1 = getScratchByteArray();
// allocate another
final byte[] array2 = byteArray();
int pos1;
int pos2;
int count1;
int count2;
while (true) {
pos1 = 0;
pos2 = 0;
for (int index = 0; index < DEFAULT_BUFFER_SIZE; index++) {
if (pos1 == index) {
do {
count1 = input1.read(array1, pos1, DEFAULT_BUFFER_SIZE - pos1);
} while (count1 == 0);
if (count1 == EOF) {
return pos2 == index && input2.read() == EOF;
}
pos1 += count1;
}
if (pos2 == index) {
do {
count2 = input2.read(array2, pos2, DEFAULT_BUFFER_SIZE - pos2);
} while (count2 == 0);
if (count2 == EOF) {
return pos1 == index && input1.read() == EOF;
}
pos2 += count2;
}
if (array1[index] != array2[index]) {
return false;
}
}
}
}
// TODO Consider making public
private static boolean contentEquals(final Iterator iterator1, final Iterator iterator2) {
while (iterator1.hasNext()) {
if (!iterator2.hasNext()) {
return false;
}
if (!Objects.equals(iterator1.next(), iterator2.next())) {
return false;
}
}
return !iterator2.hasNext();
}
/**
* Compares the contents of two Readers to determine if they are equal or not.
*
* This method buffers the input internally using {@link BufferedReader} if they are not already buffered.
*
*
* @param input1 the first reader
* @param input2 the second reader
* @return true if the content of the readers are equal or they both don't exist, false otherwise
* @throws NullPointerException if either input is null
* @throws IOException if an I/O error occurs
* @since 1.1
*/
public static boolean contentEquals(final Reader input1, final Reader input2) throws IOException {
if (input1 == input2) {
return true;
}
if (input1 == null || input2 == null) {
return false;
}
// reuse one
final char[] array1 = getScratchCharArray();
// but allocate another
final char[] array2 = charArray();
int pos1;
int pos2;
int count1;
int count2;
while (true) {
pos1 = 0;
pos2 = 0;
for (int index = 0; index < DEFAULT_BUFFER_SIZE; index++) {
if (pos1 == index) {
do {
count1 = input1.read(array1, pos1, DEFAULT_BUFFER_SIZE - pos1);
} while (count1 == 0);
if (count1 == EOF) {
return pos2 == index && input2.read() == EOF;
}
pos1 += count1;
}
if (pos2 == index) {
do {
count2 = input2.read(array2, pos2, DEFAULT_BUFFER_SIZE - pos2);
} while (count2 == 0);
if (count2 == EOF) {
return pos1 == index && input1.read() == EOF;
}
pos2 += count2;
}
if (array1[index] != array2[index]) {
return false;
}
}
}
}
// TODO Consider making public
private static boolean contentEquals(final Stream stream1, final Stream stream2) {
if (stream1 == stream2) {
return true;
}
if (stream1 == null || stream2 == null) {
return false;
}
return contentEquals(stream1.iterator(), stream2.iterator());
}
// TODO Consider making public
private static boolean contentEqualsIgnoreEOL(final BufferedReader reader1, final BufferedReader reader2) {
if (reader1 == reader2) {
return true;
}
if (reader1 == null || reader2 == null) {
return false;
}
return contentEquals(reader1.lines(), reader2.lines());
}
/**
* Compares the contents of two Readers to determine if they are equal or
* not, ignoring EOL characters.
*
* This method buffers the input internally using
* {@link BufferedReader} if they are not already buffered.
*
*
* @param reader1 the first reader
* @param reader2 the second reader
* @return true if the content of the readers are equal (ignoring EOL differences), false otherwise
* @throws NullPointerException if either input is null
* @throws UncheckedIOException if an I/O error occurs
* @since 2.2
*/
@SuppressWarnings("resource")
public static boolean contentEqualsIgnoreEOL(final Reader reader1, final Reader reader2) throws UncheckedIOException {
if (reader1 == reader2) {
return true;
}
if (reader1 == null || reader2 == null) {
return false;
}
return contentEqualsIgnoreEOL(toBufferedReader(reader1), toBufferedReader(reader2));
}
/**
* Copies bytes from an {@link InputStream} to an {@link OutputStream}.
*
* This method buffers the input internally, so there is no need to use a {@link BufferedInputStream}.
*
*
* Large streams (over 2GB) will return a bytes copied value of {@code -1} after the copy has completed since
* the correct number of bytes cannot be returned as an int. For large streams use the
* {@link #copyLarge(InputStream, OutputStream)} method.
*
*
* @param inputStream the {@link InputStream} to read.
* @param outputStream the {@link OutputStream} to write.
* @return the number of bytes copied, or -1 if greater than {@link Integer#MAX_VALUE}.
* @throws NullPointerException if the InputStream is {@code null}.
* @throws NullPointerException if the OutputStream is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 1.1
*/
public static int copy(final InputStream inputStream, final OutputStream outputStream) throws IOException {
final long count = copyLarge(inputStream, outputStream);
return count > Integer.MAX_VALUE ? EOF : (int) count;
}
/**
* Copies bytes from an {@link InputStream} to an {@link OutputStream} using an internal buffer of the
* given size.
*
* This method buffers the input internally, so there is no need to use a {@link BufferedInputStream}.
*
*
* @param inputStream the {@link InputStream} to read.
* @param outputStream the {@link OutputStream} to write to
* @param bufferSize the bufferSize used to copy from the input to the output
* @return the number of bytes copied.
* @throws NullPointerException if the InputStream is {@code null}.
* @throws NullPointerException if the OutputStream is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 2.5
*/
public static long copy(final InputStream inputStream, final OutputStream outputStream, final int bufferSize)
throws IOException {
return copyLarge(inputStream, outputStream, IOUtils.byteArray(bufferSize));
}
/**
* Copies bytes from an {@link InputStream} to chars on a
* {@link Writer} using the default character encoding of the platform.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* This method uses {@link InputStreamReader}.
*
*
* @param input the {@link InputStream} to read
* @param writer the {@link Writer} to write to
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 1.1
* @deprecated Use {@link #copy(InputStream, Writer, Charset)} instead
*/
@Deprecated
public static void copy(final InputStream input, final Writer writer)
throws IOException {
copy(input, writer, Charset.defaultCharset());
}
/**
* Copies bytes from an {@link InputStream} to chars on a
* {@link Writer} using the specified character encoding.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* This method uses {@link InputStreamReader}.
*
*
* @param input the {@link InputStream} to read
* @param writer the {@link Writer} to write to
* @param inputCharset the charset to use for the input stream, null means platform default
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 2.3
*/
public static void copy(final InputStream input, final Writer writer, final Charset inputCharset)
throws IOException {
final InputStreamReader reader = new InputStreamReader(input, Charsets.toCharset(inputCharset));
copy(reader, writer);
}
/**
* Copies bytes from an {@link InputStream} to chars on a
* {@link Writer} using the specified character encoding.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* Character encoding names can be found at
* IANA.
*
*
* This method uses {@link InputStreamReader}.
*
*
* @param input the {@link InputStream} to read
* @param writer the {@link Writer} to write to
* @param inputCharsetName the name of the requested charset for the InputStream, null means platform default
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
*/
public static void copy(final InputStream input, final Writer writer, final String inputCharsetName)
throws IOException {
copy(input, writer, Charsets.toCharset(inputCharsetName));
}
/**
* Copies bytes from a {@link java.io.ByteArrayOutputStream} to a {@link QueueInputStream}.
*
* Unlike using JDK {@link java.io.PipedInputStream} and {@link java.io.PipedOutputStream} for this, this
* solution works safely in a single thread environment.
*
*
* Example usage:
*
*
*
* ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
* outputStream.writeBytes("hello world".getBytes(StandardCharsets.UTF_8));
*
* InputStream inputStream = IOUtils.copy(outputStream);
*
*
* @param outputStream the {@link java.io.ByteArrayOutputStream} to read.
* @return the {@link QueueInputStream} filled with the content of the outputStream.
* @throws NullPointerException if the {@link java.io.ByteArrayOutputStream} is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 2.12
*/
@SuppressWarnings("resource") // streams are closed by the caller.
public static QueueInputStream copy(final java.io.ByteArrayOutputStream outputStream) throws IOException {
Objects.requireNonNull(outputStream, "outputStream");
final QueueInputStream in = new QueueInputStream();
outputStream.writeTo(in.newQueueOutputStream());
return in;
}
/**
* Copies chars from a {@link Reader} to a {@link Appendable}.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* Large streams (over 2GB) will return a chars copied value of
* {@code -1} after the copy has completed since the correct
* number of chars cannot be returned as an int. For large streams
* use the {@link #copyLarge(Reader, Writer)} method.
*
*
* @param reader the {@link Reader} to read
* @param output the {@link Appendable} to write to
* @return the number of characters copied, or -1 if > Integer.MAX_VALUE
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 2.7
*/
public static long copy(final Reader reader, final Appendable output) throws IOException {
return copy(reader, output, CharBuffer.allocate(DEFAULT_BUFFER_SIZE));
}
/**
* Copies chars from a {@link Reader} to an {@link Appendable}.
*
* This method uses the provided buffer, so there is no need to use a
* {@link BufferedReader}.
*
*
* @param reader the {@link Reader} to read
* @param output the {@link Appendable} to write to
* @param buffer the buffer to be used for the copy
* @return the number of characters copied
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 2.7
*/
public static long copy(final Reader reader, final Appendable output, final CharBuffer buffer) throws IOException {
long count = 0;
int n;
while (EOF != (n = reader.read(buffer))) {
buffer.flip();
output.append(buffer, 0, n);
count += n;
}
return count;
}
/**
* Copies chars from a {@link Reader} to bytes on an
* {@link OutputStream} using the default character encoding of the
* platform, and calling flush.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* Due to the implementation of OutputStreamWriter, this method performs a
* flush.
*
*
* This method uses {@link OutputStreamWriter}.
*
*
* @param reader the {@link Reader} to read
* @param output the {@link OutputStream} to write to
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 1.1
* @deprecated Use {@link #copy(Reader, OutputStream, Charset)} instead
*/
@Deprecated
public static void copy(final Reader reader, final OutputStream output)
throws IOException {
copy(reader, output, Charset.defaultCharset());
}
/**
* Copies chars from a {@link Reader} to bytes on an
* {@link OutputStream} using the specified character encoding, and
* calling flush.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* Due to the implementation of OutputStreamWriter, this method performs a
* flush.
*
*
* This method uses {@link OutputStreamWriter}.
*
*
* @param reader the {@link Reader} to read
* @param output the {@link OutputStream} to write to
* @param outputCharset the charset to use for the OutputStream, null means platform default
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 2.3
*/
public static void copy(final Reader reader, final OutputStream output, final Charset outputCharset)
throws IOException {
final OutputStreamWriter writer = new OutputStreamWriter(output, Charsets.toCharset(outputCharset));
copy(reader, writer);
// XXX Unless anyone is planning on rewriting OutputStreamWriter,
// we have to flush here.
writer.flush();
}
/**
* Copies chars from a {@link Reader} to bytes on an
* {@link OutputStream} using the specified character encoding, and
* calling flush.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* Character encoding names can be found at
* IANA.
*
*
* Due to the implementation of OutputStreamWriter, this method performs a
* flush.
*
*
* This method uses {@link OutputStreamWriter}.
*
*
* @param reader the {@link Reader} to read
* @param output the {@link OutputStream} to write to
* @param outputCharsetName the name of the requested charset for the OutputStream, null means platform default
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
*/
public static void copy(final Reader reader, final OutputStream output, final String outputCharsetName)
throws IOException {
copy(reader, output, Charsets.toCharset(outputCharsetName));
}
/**
* Copies chars from a {@link Reader} to a {@link Writer}.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* Large streams (over 2GB) will return a chars copied value of
* {@code -1} after the copy has completed since the correct
* number of chars cannot be returned as an int. For large streams
* use the {@link #copyLarge(Reader, Writer)} method.
*
*
* @param reader the {@link Reader} to read.
* @param writer the {@link Writer} to write.
* @return the number of characters copied, or -1 if > Integer.MAX_VALUE
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 1.1
*/
public static int copy(final Reader reader, final Writer writer) throws IOException {
final long count = copyLarge(reader, writer);
if (count > Integer.MAX_VALUE) {
return EOF;
}
return (int) count;
}
/**
* Copies bytes from a {@link URL} to an {@link OutputStream}.
*
* This method buffers the input internally, so there is no need to use a {@link BufferedInputStream}.
*
*
* The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
*
*
* @param url the {@link URL} to read.
* @param file the {@link OutputStream} to write.
* @return the number of bytes copied.
* @throws NullPointerException if the URL is {@code null}.
* @throws NullPointerException if the OutputStream is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 2.9.0
*/
public static long copy(final URL url, final File file) throws IOException {
try (OutputStream outputStream = Files.newOutputStream(Objects.requireNonNull(file, "file").toPath())) {
return copy(url, outputStream);
}
}
/**
* Copies bytes from a {@link URL} to an {@link OutputStream}.
*
* This method buffers the input internally, so there is no need to use a {@link BufferedInputStream}.
*
*
* The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
*
*
* @param url the {@link URL} to read.
* @param outputStream the {@link OutputStream} to write.
* @return the number of bytes copied.
* @throws NullPointerException if the URL is {@code null}.
* @throws NullPointerException if the OutputStream is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 2.9.0
*/
public static long copy(final URL url, final OutputStream outputStream) throws IOException {
try (InputStream inputStream = Objects.requireNonNull(url, "url").openStream()) {
return copyLarge(inputStream, outputStream);
}
}
/**
* Copies bytes from a large (over 2GB) {@link InputStream} to an
* {@link OutputStream}.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
*
*
* @param inputStream the {@link InputStream} to read.
* @param outputStream the {@link OutputStream} to write.
* @return the number of bytes copied.
* @throws NullPointerException if the InputStream is {@code null}.
* @throws NullPointerException if the OutputStream is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 1.3
*/
public static long copyLarge(final InputStream inputStream, final OutputStream outputStream)
throws IOException {
return copy(inputStream, outputStream, DEFAULT_BUFFER_SIZE);
}
/**
* Copies bytes from a large (over 2GB) {@link InputStream} to an
* {@link OutputStream}.
*
* This method uses the provided buffer, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param inputStream the {@link InputStream} to read.
* @param outputStream the {@link OutputStream} to write.
* @param buffer the buffer to use for the copy
* @return the number of bytes copied.
* @throws NullPointerException if the InputStream is {@code null}.
* @throws NullPointerException if the OutputStream is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 2.2
*/
@SuppressWarnings("resource") // streams are closed by the caller.
public static long copyLarge(final InputStream inputStream, final OutputStream outputStream, final byte[] buffer)
throws IOException {
Objects.requireNonNull(inputStream, "inputStream");
Objects.requireNonNull(outputStream, "outputStream");
long count = 0;
int n;
while (EOF != (n = inputStream.read(buffer))) {
outputStream.write(buffer, 0, n);
count += n;
}
return count;
}
/**
* Copies some or all bytes from a large (over 2GB) {@link InputStream} to an
* {@link OutputStream}, optionally skipping input bytes.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* Note that the implementation uses {@link #skip(InputStream, long)}.
* This means that the method may be considerably less efficient than using the actual skip implementation,
* this is done to guarantee that the correct number of characters are skipped.
*
* The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
*
* @param input the {@link InputStream} to read
* @param output the {@link OutputStream} to write to
* @param inputOffset : number of bytes to skip from input before copying
* -ve values are ignored
* @param length number of bytes to copy. -ve means all
* @return the number of bytes copied
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 2.2
*/
public static long copyLarge(final InputStream input, final OutputStream output, final long inputOffset,
final long length) throws IOException {
return copyLarge(input, output, inputOffset, length, getScratchByteArray());
}
/**
* Copies some or all bytes from a large (over 2GB) {@link InputStream} to an
* {@link OutputStream}, optionally skipping input bytes.
*
* This method uses the provided buffer, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* Note that the implementation uses {@link #skip(InputStream, long)}.
* This means that the method may be considerably less efficient than using the actual skip implementation,
* this is done to guarantee that the correct number of characters are skipped.
*
*
* @param input the {@link InputStream} to read
* @param output the {@link OutputStream} to write to
* @param inputOffset number of bytes to skip from input before copying
* -ve values are ignored
* @param length number of bytes to copy. -ve means all
* @param buffer the buffer to use for the copy
* @return the number of bytes copied
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 2.2
*/
public static long copyLarge(final InputStream input, final OutputStream output,
final long inputOffset, final long length, final byte[] buffer) throws IOException {
if (inputOffset > 0) {
skipFully(input, inputOffset);
}
if (length == 0) {
return 0;
}
final int bufferLength = buffer.length;
int bytesToRead = bufferLength;
if (length > 0 && length < bufferLength) {
bytesToRead = (int) length;
}
int read;
long totalRead = 0;
while (bytesToRead > 0 && EOF != (read = input.read(buffer, 0, bytesToRead))) {
output.write(buffer, 0, read);
totalRead += read;
if (length > 0) { // only adjust length if not reading to the end
// Note the cast must work because buffer.length is an integer
bytesToRead = (int) Math.min(length - totalRead, bufferLength);
}
}
return totalRead;
}
/**
* Copies chars from a large (over 2GB) {@link Reader} to a {@link Writer}.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
*
*
* @param reader the {@link Reader} to source.
* @param writer the {@link Writer} to target.
* @return the number of characters copied
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 1.3
*/
public static long copyLarge(final Reader reader, final Writer writer) throws IOException {
return copyLarge(reader, writer, getScratchCharArray());
}
/**
* Copies chars from a large (over 2GB) {@link Reader} to a {@link Writer}.
*
* This method uses the provided buffer, so there is no need to use a
* {@link BufferedReader}.
*
*
* @param reader the {@link Reader} to source.
* @param writer the {@link Writer} to target.
* @param buffer the buffer to be used for the copy
* @return the number of characters copied
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 2.2
*/
public static long copyLarge(final Reader reader, final Writer writer, final char[] buffer) throws IOException {
long count = 0;
int n;
while (EOF != (n = reader.read(buffer))) {
writer.write(buffer, 0, n);
count += n;
}
return count;
}
/**
* Copies some or all chars from a large (over 2GB) {@link InputStream} to an
* {@link OutputStream}, optionally skipping input chars.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
*
*
* @param reader the {@link Reader} to read
* @param writer the {@link Writer} to write to
* @param inputOffset number of chars to skip from input before copying
* -ve values are ignored
* @param length number of chars to copy. -ve means all
* @return the number of chars copied
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 2.2
*/
public static long copyLarge(final Reader reader, final Writer writer, final long inputOffset, final long length)
throws IOException {
return copyLarge(reader, writer, inputOffset, length, getScratchCharArray());
}
/**
* Copies some or all chars from a large (over 2GB) {@link InputStream} to an
* {@link OutputStream}, optionally skipping input chars.
*
* This method uses the provided buffer, so there is no need to use a
* {@link BufferedReader}.
*
*
* @param reader the {@link Reader} to read
* @param writer the {@link Writer} to write to
* @param inputOffset number of chars to skip from input before copying
* -ve values are ignored
* @param length number of chars to copy. -ve means all
* @param buffer the buffer to be used for the copy
* @return the number of chars copied
* @throws NullPointerException if the input or output is null
* @throws IOException if an I/O error occurs
* @since 2.2
*/
public static long copyLarge(final Reader reader, final Writer writer, final long inputOffset, final long length,
final char[] buffer)
throws IOException {
if (inputOffset > 0) {
skipFully(reader, inputOffset);
}
if (length == 0) {
return 0;
}
int bytesToRead = buffer.length;
if (length > 0 && length < buffer.length) {
bytesToRead = (int) length;
}
int read;
long totalRead = 0;
while (bytesToRead > 0 && EOF != (read = reader.read(buffer, 0, bytesToRead))) {
writer.write(buffer, 0, read);
totalRead += read;
if (length > 0) { // only adjust length if not reading to the end
// Note the cast must work because buffer.length is an integer
bytesToRead = (int) Math.min(length - totalRead, buffer.length);
}
}
return totalRead;
}
/**
* Fills the given array with 0s.
*
* @param arr The non-null array to fill.
* @return The given array.
*/
private static byte[] fill0(final byte[] arr) {
Arrays.fill(arr, (byte) 0);
return arr;
}
/**
* Fills the given array with 0s.
*
* @param arr The non-null array to fill.
* @return The given array.
*/
private static char[] fill0(final char[] arr) {
Arrays.fill(arr, (char) 0);
return arr;
}
/**
* Gets the internal byte array buffer, intended for both reading and writing.
*
* @return the internal byte array buffer, intended for both reading and writing.
*/
static byte[] getScratchByteArray() {
return fill0(SCRATCH_BYTE_BUFFER_RW.get());
}
/**
* Gets the internal byte array intended for write only operations.
*
* @return the internal byte array intended for write only operations.
*/
static byte[] getScratchByteArrayWriteOnly() {
return fill0(SCRATCH_BYTE_BUFFER_WO);
}
/**
* Gets the char byte array buffer, intended for both reading and writing.
*
* @return the char byte array buffer, intended for both reading and writing.
*/
static char[] getScratchCharArray() {
return fill0(SCRATCH_CHAR_BUFFER_RW.get());
}
/**
* Gets the internal char array intended for write only operations.
*
* @return the internal char array intended for write only operations.
*/
static char[] getScratchCharArrayWriteOnly() {
return fill0(SCRATCH_CHAR_BUFFER_WO);
}
/**
* Returns the length of the given array in a null-safe manner.
*
* @param array an array or null
* @return the array length -- or 0 if the given array is null.
* @since 2.7
*/
public static int length(final byte[] array) {
return array == null ? 0 : array.length;
}
/**
* Returns the length of the given array in a null-safe manner.
*
* @param array an array or null
* @return the array length -- or 0 if the given array is null.
* @since 2.7
*/
public static int length(final char[] array) {
return array == null ? 0 : array.length;
}
/**
* Returns the length of the given CharSequence in a null-safe manner.
*
* @param csq a CharSequence or null
* @return the CharSequence length -- or 0 if the given CharSequence is null.
* @since 2.7
*/
public static int length(final CharSequence csq) {
return csq == null ? 0 : csq.length();
}
/**
* Returns the length of the given array in a null-safe manner.
*
* @param array an array or null
* @return the array length -- or 0 if the given array is null.
* @since 2.7
*/
public static int length(final Object[] array) {
return array == null ? 0 : array.length;
}
/**
* Returns an Iterator for the lines in an {@link InputStream}, using
* the character encoding specified (or default encoding if null).
*
* {@link LineIterator} holds a reference to the open
* {@link InputStream} specified here. When you have finished with
* the iterator you should close the stream to free internal resources.
* This can be done by using a try-with-resources block, closing the stream directly, or by calling
* {@link LineIterator#close()}.
*
*
* The recommended usage pattern is:
*
*
* try {
* LineIterator it = IOUtils.lineIterator(stream, charset);
* while (it.hasNext()) {
* String line = it.nextLine();
* /// do something with line
* }
* } finally {
* IOUtils.closeQuietly(stream);
* }
*
*
* @param input the {@link InputStream} to read, not null
* @param charset the charset to use, null means platform default
* @return an Iterator of the lines in the reader, never null
* @throws IllegalArgumentException if the input is null
* @since 2.3
*/
public static LineIterator lineIterator(final InputStream input, final Charset charset) {
return new LineIterator(new InputStreamReader(input, Charsets.toCharset(charset)));
}
/**
* Returns an Iterator for the lines in an {@link InputStream}, using
* the character encoding specified (or default encoding if null).
*
* {@link LineIterator} holds a reference to the open
* {@link InputStream} specified here. When you have finished with
* the iterator you should close the stream to free internal resources.
* This can be done by using a try-with-resources block, closing the stream directly, or by calling
* {@link LineIterator#close()}.
*
*
* The recommended usage pattern is:
*
*
* try {
* LineIterator it = IOUtils.lineIterator(stream, StandardCharsets.UTF_8.name());
* while (it.hasNext()) {
* String line = it.nextLine();
* /// do something with line
* }
* } finally {
* IOUtils.closeQuietly(stream);
* }
*
*
* @param input the {@link InputStream} to read, not null
* @param charsetName the encoding to use, null means platform default
* @return an Iterator of the lines in the reader, never null
* @throws IllegalArgumentException if the input is null
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.2
*/
public static LineIterator lineIterator(final InputStream input, final String charsetName) {
return lineIterator(input, Charsets.toCharset(charsetName));
}
/**
* Returns an Iterator for the lines in a {@link Reader}.
*
* {@link LineIterator} holds a reference to the open
* {@link Reader} specified here. When you have finished with the
* iterator you should close the reader to free internal resources.
* This can be done by using a try-with-resources block, closing the reader directly, or by calling
* {@link LineIterator#close()}.
*
*
* The recommended usage pattern is:
*
*
* try {
* LineIterator it = IOUtils.lineIterator(reader);
* while (it.hasNext()) {
* String line = it.nextLine();
* /// do something with line
* }
* } finally {
* IOUtils.closeQuietly(reader);
* }
*
*
* @param reader the {@link Reader} to read, not null
* @return an Iterator of the lines in the reader, never null
* @throws NullPointerException if the reader is null
* @since 1.2
*/
public static LineIterator lineIterator(final Reader reader) {
return new LineIterator(reader);
}
/**
* Reads bytes from an input stream.
* This implementation guarantees that it will read as many bytes
* as possible before giving up; this may not always be the case for
* subclasses of {@link InputStream}.
*
* @param input where to read input from
* @param buffer destination
* @return actual length read; may be less than requested if EOF was reached
* @throws IOException if a read error occurs
* @since 2.2
*/
public static int read(final InputStream input, final byte[] buffer) throws IOException {
return read(input, buffer, 0, buffer.length);
}
/**
* Reads bytes from an input stream.
* This implementation guarantees that it will read as many bytes
* as possible before giving up; this may not always be the case for
* subclasses of {@link InputStream}.
*
* @param input where to read input
* @param buffer destination
* @param offset initial offset into buffer
* @param length length to read, must be >= 0
* @return actual length read; may be less than requested if EOF was reached
* @throws IllegalArgumentException if length is negative
* @throws IOException if a read error occurs
* @since 2.2
*/
public static int read(final InputStream input, final byte[] buffer, final int offset, final int length)
throws IOException {
if (length == 0) {
return 0;
}
return read(input::read, buffer, offset, length);
}
/**
* Reads bytes from an input. This implementation guarantees that it will read as many bytes as possible before giving up; this may not always be the case
* for subclasses of {@link InputStream}.
*
* @param input How to read input
* @param buffer destination
* @param offset initial offset into buffer
* @param length length to read, must be >= 0
* @return actual length read; may be less than requested if EOF was reached
* @throws IllegalArgumentException if length is negative
* @throws IOException if a read error occurs
* @since 2.2
*/
static int read(final IOTriFunction input, final byte[] buffer, final int offset, final int length)
throws IOException {
if (length < 0) {
throw new IllegalArgumentException("Length must not be negative: " + length);
}
int remaining = length;
while (remaining > 0) {
final int location = length - remaining;
final int count = input.apply(buffer, offset + location, remaining);
if (EOF == count) {
break;
}
remaining -= count;
}
return length - remaining;
}
/**
* Reads bytes from a ReadableByteChannel.
*
* This implementation guarantees that it will read as many bytes
* as possible before giving up; this may not always be the case for
* subclasses of {@link ReadableByteChannel}.
*
*
* @param input the byte channel to read
* @param buffer byte buffer destination
* @return the actual length read; may be less than requested if EOF was reached
* @throws IOException if a read error occurs
* @since 2.5
*/
public static int read(final ReadableByteChannel input, final ByteBuffer buffer) throws IOException {
final int length = buffer.remaining();
while (buffer.remaining() > 0) {
final int count = input.read(buffer);
if (EOF == count) { // EOF
break;
}
}
return length - buffer.remaining();
}
/**
* Reads characters from an input character stream.
* This implementation guarantees that it will read as many characters
* as possible before giving up; this may not always be the case for
* subclasses of {@link Reader}.
*
* @param reader where to read input from
* @param buffer destination
* @return actual length read; may be less than requested if EOF was reached
* @throws IOException if a read error occurs
* @since 2.2
*/
public static int read(final Reader reader, final char[] buffer) throws IOException {
return read(reader, buffer, 0, buffer.length);
}
/**
* Reads characters from an input character stream.
* This implementation guarantees that it will read as many characters
* as possible before giving up; this may not always be the case for
* subclasses of {@link Reader}.
*
* @param reader where to read input from
* @param buffer destination
* @param offset initial offset into buffer
* @param length length to read, must be >= 0
* @return actual length read; may be less than requested if EOF was reached
* @throws IllegalArgumentException if length is negative
* @throws IOException if a read error occurs
* @since 2.2
*/
public static int read(final Reader reader, final char[] buffer, final int offset, final int length)
throws IOException {
if (length < 0) {
throw new IllegalArgumentException("Length must not be negative: " + length);
}
int remaining = length;
while (remaining > 0) {
final int location = length - remaining;
final int count = reader.read(buffer, offset + location, remaining);
if (EOF == count) { // EOF
break;
}
remaining -= count;
}
return length - remaining;
}
/**
* Reads the requested number of bytes or fail if there are not enough left.
*
* This allows for the possibility that {@link InputStream#read(byte[], int, int)} may
* not read as many bytes as requested (most likely because of reaching EOF).
*
*
* @param input where to read input from
* @param buffer destination
*
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if length is negative
* @throws EOFException if the number of bytes read was incorrect
* @since 2.2
*/
public static void readFully(final InputStream input, final byte[] buffer) throws IOException {
readFully(input, buffer, 0, buffer.length);
}
/**
* Reads the requested number of bytes or fail if there are not enough left.
*
* This allows for the possibility that {@link InputStream#read(byte[], int, int)} may
* not read as many bytes as requested (most likely because of reaching EOF).
*
*
* @param input where to read input from
* @param buffer destination
* @param offset initial offset into buffer
* @param length length to read, must be >= 0
*
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if length is negative
* @throws EOFException if the number of bytes read was incorrect
* @since 2.2
*/
public static void readFully(final InputStream input, final byte[] buffer, final int offset, final int length)
throws IOException {
final int actual = read(input, buffer, offset, length);
if (actual != length) {
throw new EOFException("Length to read: " + length + " actual: " + actual);
}
}
/**
* Reads the requested number of bytes or fail if there are not enough left.
*
* This allows for the possibility that {@link InputStream#read(byte[], int, int)} may
* not read as many bytes as requested (most likely because of reaching EOF).
*
*
* @param input where to read input from
* @param length length to read, must be >= 0
* @return the bytes read from input
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if length is negative
* @throws EOFException if the number of bytes read was incorrect
* @since 2.5
*/
public static byte[] readFully(final InputStream input, final int length) throws IOException {
final byte[] buffer = byteArray(length);
readFully(input, buffer, 0, buffer.length);
return buffer;
}
/**
* Reads the requested number of bytes or fail if there are not enough left.
*
* This allows for the possibility that {@link ReadableByteChannel#read(ByteBuffer)} may
* not read as many bytes as requested (most likely because of reaching EOF).
*
*
* @param input the byte channel to read
* @param buffer byte buffer destination
* @throws IOException if there is a problem reading the file
* @throws EOFException if the number of bytes read was incorrect
* @since 2.5
*/
public static void readFully(final ReadableByteChannel input, final ByteBuffer buffer) throws IOException {
final int expected = buffer.remaining();
final int actual = read(input, buffer);
if (actual != expected) {
throw new EOFException("Length to read: " + expected + " actual: " + actual);
}
}
/**
* Reads the requested number of characters or fail if there are not enough left.
*
* This allows for the possibility that {@link Reader#read(char[], int, int)} may
* not read as many characters as requested (most likely because of reaching EOF).
*
*
* @param reader where to read input from
* @param buffer destination
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if length is negative
* @throws EOFException if the number of characters read was incorrect
* @since 2.2
*/
public static void readFully(final Reader reader, final char[] buffer) throws IOException {
readFully(reader, buffer, 0, buffer.length);
}
/**
* Reads the requested number of characters or fail if there are not enough left.
*
* This allows for the possibility that {@link Reader#read(char[], int, int)} may
* not read as many characters as requested (most likely because of reaching EOF).
*
*
* @param reader where to read input from
* @param buffer destination
* @param offset initial offset into buffer
* @param length length to read, must be >= 0
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if length is negative
* @throws EOFException if the number of characters read was incorrect
* @since 2.2
*/
public static void readFully(final Reader reader, final char[] buffer, final int offset, final int length)
throws IOException {
final int actual = read(reader, buffer, offset, length);
if (actual != length) {
throw new EOFException("Length to read: " + length + " actual: " + actual);
}
}
/**
* Gets the contents of an {@link InputStream} as a list of Strings,
* one entry per line, using the default character encoding of the platform.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param input the {@link InputStream} to read, not null
* @return the list of Strings, never null
* @throws NullPointerException if the input is null
* @throws UncheckedIOException if an I/O error occurs
* @since 1.1
* @deprecated Use {@link #readLines(InputStream, Charset)} instead
*/
@Deprecated
public static List readLines(final InputStream input) throws UncheckedIOException {
return readLines(input, Charset.defaultCharset());
}
/**
* Gets the contents of an {@link InputStream} as a list of Strings,
* one entry per line, using the specified character encoding.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param input the {@link InputStream} to read, not null
* @param charset the charset to use, null means platform default
* @return the list of Strings, never null
* @throws NullPointerException if the input is null
* @throws UncheckedIOException if an I/O error occurs
* @since 2.3
*/
public static List readLines(final InputStream input, final Charset charset) throws UncheckedIOException {
return readLines(new InputStreamReader(input, Charsets.toCharset(charset)));
}
/**
* Gets the contents of an {@link InputStream} as a list of Strings,
* one entry per line, using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param input the {@link InputStream} to read, not null
* @param charsetName the name of the requested charset, null means platform default
* @return the list of Strings, never null
* @throws NullPointerException if the input is null
* @throws UncheckedIOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
*/
public static List readLines(final InputStream input, final String charsetName) throws UncheckedIOException {
return readLines(input, Charsets.toCharset(charsetName));
}
/**
* Gets the contents of a {@link Reader} as a list of Strings,
* one entry per line.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* @param reader the {@link Reader} to read, not null
* @return the list of Strings, never null
* @throws NullPointerException if the input is null
* @throws UncheckedIOException if an I/O error occurs
* @since 1.1
*/
@SuppressWarnings("resource") // reader wraps input and is the responsibility of the caller.
public static List readLines(final Reader reader) throws UncheckedIOException {
return toBufferedReader(reader).lines().collect(Collectors.toList());
}
/**
* Gets the contents of a resource as a byte array.
*
* Delegates to {@link #resourceToByteArray(String, ClassLoader) resourceToByteArray(String, null)}.
*
*
* @param name The resource name.
* @return the requested byte array
* @throws IOException if an I/O error occurs or the resource is not found.
* @see #resourceToByteArray(String, ClassLoader)
* @since 2.6
*/
public static byte[] resourceToByteArray(final String name) throws IOException {
return resourceToByteArray(name, null);
}
/**
* Gets the contents of a resource as a byte array.
*
* Delegates to {@link #resourceToURL(String, ClassLoader)}.
*
*
* @param name The resource name.
* @param classLoader the class loader that the resolution of the resource is delegated to
* @return the requested byte array
* @throws IOException if an I/O error occurs or the resource is not found.
* @see #resourceToURL(String, ClassLoader)
* @since 2.6
*/
public static byte[] resourceToByteArray(final String name, final ClassLoader classLoader) throws IOException {
return toByteArray(resourceToURL(name, classLoader));
}
/**
* Gets the contents of a resource as a String using the specified character encoding.
*
* Delegates to {@link #resourceToString(String, Charset, ClassLoader) resourceToString(String, Charset, null)}.
*
*
* @param name The resource name.
* @param charset the charset to use, null means platform default
* @return the requested String
* @throws IOException if an I/O error occurs or the resource is not found.
* @see #resourceToString(String, Charset, ClassLoader)
* @since 2.6
*/
public static String resourceToString(final String name, final Charset charset) throws IOException {
return resourceToString(name, charset, null);
}
/**
* Gets the contents of a resource as a String using the specified character encoding.
*
* Delegates to {@link #resourceToURL(String, ClassLoader)}.
*
*
* @param name The resource name.
* @param charset the Charset to use, null means platform default
* @param classLoader the class loader that the resolution of the resource is delegated to
* @return the requested String
* @throws IOException if an I/O error occurs.
* @see #resourceToURL(String, ClassLoader)
* @since 2.6
*/
public static String resourceToString(final String name, final Charset charset, final ClassLoader classLoader) throws IOException {
return toString(resourceToURL(name, classLoader), charset);
}
/**
* Gets a URL pointing to the given resource.
*
* Delegates to {@link #resourceToURL(String, ClassLoader) resourceToURL(String, null)}.
*
*
* @param name The resource name.
* @return A URL object for reading the resource.
* @throws IOException if the resource is not found.
* @since 2.6
*/
public static URL resourceToURL(final String name) throws IOException {
return resourceToURL(name, null);
}
/**
* Gets a URL pointing to the given resource.
*
* If the {@code classLoader} is not null, call {@link ClassLoader#getResource(String)}, otherwise call
* {@link Class#getResource(String) IOUtils.class.getResource(name)}.
*
*
* @param name The resource name.
* @param classLoader Delegate to this class loader if not null
* @return A URL object for reading the resource.
* @throws IOException if the resource is not found.
* @since 2.6
*/
public static URL resourceToURL(final String name, final ClassLoader classLoader) throws IOException {
// What about the thread context class loader?
// What about the system class loader?
final URL resource = classLoader == null ? IOUtils.class.getResource(name) : classLoader.getResource(name);
if (resource == null) {
throw new IOException("Resource not found: " + name);
}
return resource;
}
/**
* Skips bytes from an input byte stream.
* This implementation guarantees that it will read as many bytes
* as possible before giving up; this may not always be the case for
* skip() implementations in subclasses of {@link InputStream}.
*
* Note that the implementation uses {@link InputStream#read(byte[], int, int)} rather
* than delegating to {@link InputStream#skip(long)}.
* This means that the method may be considerably less efficient than using the actual skip implementation,
* this is done to guarantee that the correct number of bytes are skipped.
*
*
* @param input byte stream to skip
* @param toSkip number of bytes to skip.
* @return number of bytes actually skipped.
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if toSkip is negative
* @see InputStream#skip(long)
* @see IO-203 - Add skipFully() method for InputStreams
* @since 2.0
*/
public static long skip(final InputStream input, final long toSkip) throws IOException {
return skip(input, toSkip, IOUtils::getScratchByteArrayWriteOnly);
}
/**
* Skips bytes from an input byte stream.
*
* Intended for special cases when customization of the temporary buffer is needed because, for example, a nested input stream has requirements for the
* bytes read. For example, when using {@link InflaterInputStream}s from multiple threads.
*
*
* This implementation guarantees that it will read as many bytes as possible before giving up; this may not always be the case for skip() implementations
* in subclasses of {@link InputStream}.
*
*
* Note that the implementation uses {@link InputStream#read(byte[], int, int)} rather than delegating to {@link InputStream#skip(long)}. This means that
* the method may be considerably less efficient than using the actual skip implementation, this is done to guarantee that the correct number of bytes are
* skipped.
*
*
* @param input byte stream to skip
* @param toSkip number of bytes to skip.
* @param skipBufferSupplier Supplies the buffer to use for reading.
* @return number of bytes actually skipped.
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if toSkip is negative
* @see InputStream#skip(long)
* @see IO-203 - Add skipFully() method for InputStreams
* @since 2.14.0
*/
public static long skip(final InputStream input, final long toSkip, final Supplier skipBufferSupplier) throws IOException {
if (toSkip < 0) {
throw new IllegalArgumentException("Skip count must be non-negative, actual: " + toSkip);
}
//
// No need to synchronize access to SCRATCH_BYTE_BUFFER_WO: We don't care if the buffer is written multiple
// times or in parallel since the data is ignored. We reuse the same buffer, if the buffer size were variable or read-write,
// we would need to synch or use a thread local to ensure some other thread safety.
//
long remain = toSkip;
while (remain > 0) {
final byte[] skipBuffer = skipBufferSupplier.get();
// See https://issues.apache.org/jira/browse/IO-203 for why we use read() rather than delegating to skip()
final long n = input.read(skipBuffer, 0, (int) Math.min(remain, skipBuffer.length));
if (n < 0) { // EOF
break;
}
remain -= n;
}
return toSkip - remain;
}
/**
* Skips bytes from a ReadableByteChannel.
* This implementation guarantees that it will read as many bytes
* as possible before giving up.
*
* @param input ReadableByteChannel to skip
* @param toSkip number of bytes to skip.
* @return number of bytes actually skipped.
* @throws IOException if there is a problem reading the ReadableByteChannel
* @throws IllegalArgumentException if toSkip is negative
* @since 2.5
*/
public static long skip(final ReadableByteChannel input, final long toSkip) throws IOException {
if (toSkip < 0) {
throw new IllegalArgumentException("Skip count must be non-negative, actual: " + toSkip);
}
final ByteBuffer skipByteBuffer = ByteBuffer.allocate((int) Math.min(toSkip, DEFAULT_BUFFER_SIZE));
long remain = toSkip;
while (remain > 0) {
skipByteBuffer.position(0);
skipByteBuffer.limit((int) Math.min(remain, DEFAULT_BUFFER_SIZE));
final int n = input.read(skipByteBuffer);
if (n == EOF) {
break;
}
remain -= n;
}
return toSkip - remain;
}
/**
* Skips characters from an input character stream.
* This implementation guarantees that it will read as many characters
* as possible before giving up; this may not always be the case for
* skip() implementations in subclasses of {@link Reader}.
*
* Note that the implementation uses {@link Reader#read(char[], int, int)} rather
* than delegating to {@link Reader#skip(long)}.
* This means that the method may be considerably less efficient than using the actual skip implementation,
* this is done to guarantee that the correct number of characters are skipped.
*
*
* @param reader character stream to skip
* @param toSkip number of characters to skip.
* @return number of characters actually skipped.
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if toSkip is negative
* @see Reader#skip(long)
* @see IO-203 - Add skipFully() method for InputStreams
* @since 2.0
*/
public static long skip(final Reader reader, final long toSkip) throws IOException {
if (toSkip < 0) {
throw new IllegalArgumentException("Skip count must be non-negative, actual: " + toSkip);
}
long remain = toSkip;
while (remain > 0) {
// See https://issues.apache.org/jira/browse/IO-203 for why we use read() rather than delegating to skip()
final char[] charArray = getScratchCharArrayWriteOnly();
final long n = reader.read(charArray, 0, (int) Math.min(remain, charArray.length));
if (n < 0) { // EOF
break;
}
remain -= n;
}
return toSkip - remain;
}
/**
* Skips the requested number of bytes or fail if there are not enough left.
*
* This allows for the possibility that {@link InputStream#skip(long)} may
* not skip as many bytes as requested (most likely because of reaching EOF).
*
*
* Note that the implementation uses {@link #skip(InputStream, long)}.
* This means that the method may be considerably less efficient than using the actual skip implementation,
* this is done to guarantee that the correct number of characters are skipped.
*
*
* @param input stream to skip
* @param toSkip the number of bytes to skip
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if toSkip is negative
* @throws EOFException if the number of bytes skipped was incorrect
* @see InputStream#skip(long)
* @since 2.0
*/
public static void skipFully(final InputStream input, final long toSkip) throws IOException {
final long skipped = skip(input, toSkip, IOUtils::getScratchByteArrayWriteOnly);
if (skipped != toSkip) {
throw new EOFException("Bytes to skip: " + toSkip + " actual: " + skipped);
}
}
/**
* Skips the requested number of bytes or fail if there are not enough left.
*
* Intended for special cases when customization of the temporary buffer is needed because, for example, a nested input stream has requirements for the
* bytes read. For example, when using {@link InflaterInputStream}s from multiple threads.
*
*
* This allows for the possibility that {@link InputStream#skip(long)} may not skip as many bytes as requested (most likely because of reaching EOF).
*
*
* Note that the implementation uses {@link #skip(InputStream, long)}. This means that the method may be considerably less efficient than using the actual
* skip implementation, this is done to guarantee that the correct number of characters are skipped.
*
*
* @param input stream to skip
* @param toSkip the number of bytes to skip
* @param skipBufferSupplier Supplies the buffer to use for reading.
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if toSkip is negative
* @throws EOFException if the number of bytes skipped was incorrect
* @see InputStream#skip(long)
* @since 2.14.0
*/
public static void skipFully(final InputStream input, final long toSkip, final Supplier skipBufferSupplier) throws IOException {
if (toSkip < 0) {
throw new IllegalArgumentException("Bytes to skip must not be negative: " + toSkip);
}
final long skipped = skip(input, toSkip, skipBufferSupplier);
if (skipped != toSkip) {
throw new EOFException("Bytes to skip: " + toSkip + " actual: " + skipped);
}
}
/**
* Skips the requested number of bytes or fail if there are not enough left.
*
* @param input ReadableByteChannel to skip
* @param toSkip the number of bytes to skip
* @throws IOException if there is a problem reading the ReadableByteChannel
* @throws IllegalArgumentException if toSkip is negative
* @throws EOFException if the number of bytes skipped was incorrect
* @since 2.5
*/
public static void skipFully(final ReadableByteChannel input, final long toSkip) throws IOException {
if (toSkip < 0) {
throw new IllegalArgumentException("Bytes to skip must not be negative: " + toSkip);
}
final long skipped = skip(input, toSkip);
if (skipped != toSkip) {
throw new EOFException("Bytes to skip: " + toSkip + " actual: " + skipped);
}
}
/**
* Skips the requested number of characters or fail if there are not enough left.
*
* This allows for the possibility that {@link Reader#skip(long)} may
* not skip as many characters as requested (most likely because of reaching EOF).
*
*
* Note that the implementation uses {@link #skip(Reader, long)}.
* This means that the method may be considerably less efficient than using the actual skip implementation,
* this is done to guarantee that the correct number of characters are skipped.
*
*
* @param reader stream to skip
* @param toSkip the number of characters to skip
* @throws IOException if there is a problem reading the file
* @throws IllegalArgumentException if toSkip is negative
* @throws EOFException if the number of characters skipped was incorrect
* @see Reader#skip(long)
* @since 2.0
*/
public static void skipFully(final Reader reader, final long toSkip) throws IOException {
final long skipped = skip(reader, toSkip);
if (skipped != toSkip) {
throw new EOFException("Chars to skip: " + toSkip + " actual: " + skipped);
}
}
/**
* Fetches entire contents of an {@link InputStream} and represent
* same data as result InputStream.
*
* This method is useful where,
*
*
* - Source InputStream is slow.
* - It has network resources associated, so we cannot keep it open for
* long time.
* - It has network timeout associated.
*
*
* It can be used in favor of {@link #toByteArray(InputStream)}, since it
* avoids unnecessary allocation and copy of byte[].
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param input Stream to be fully buffered.
* @return A fully buffered stream.
* @throws IOException if an I/O error occurs.
* @since 2.0
*/
public static InputStream toBufferedInputStream(final InputStream input) throws IOException {
return ByteArrayOutputStream.toBufferedInputStream(input);
}
/**
* Fetches entire contents of an {@link InputStream} and represent
* same data as result InputStream.
*
* This method is useful where,
*
*
* - Source InputStream is slow.
* - It has network resources associated, so we cannot keep it open for
* long time.
* - It has network timeout associated.
*
*
* It can be used in favor of {@link #toByteArray(InputStream)}, since it
* avoids unnecessary allocation and copy of byte[].
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param input Stream to be fully buffered.
* @param size the initial buffer size
* @return A fully buffered stream.
* @throws IOException if an I/O error occurs.
* @since 2.5
*/
public static InputStream toBufferedInputStream(final InputStream input, final int size) throws IOException {
return ByteArrayOutputStream.toBufferedInputStream(input, size);
}
/**
* Returns the given reader if it is a {@link BufferedReader}, otherwise creates a BufferedReader from the given
* reader.
*
* @param reader the reader to wrap or return (not null)
* @return the given reader or a new {@link BufferedReader} for the given reader
* @throws NullPointerException if the input parameter is null
* @see #buffer(Reader)
* @since 2.2
*/
public static BufferedReader toBufferedReader(final Reader reader) {
return reader instanceof BufferedReader ? (BufferedReader) reader : new BufferedReader(reader);
}
/**
* Returns the given reader if it is a {@link BufferedReader}, otherwise creates a BufferedReader from the given
* reader.
*
* @param reader the reader to wrap or return (not null)
* @param size the buffer size, if a new BufferedReader is created.
* @return the given reader or a new {@link BufferedReader} for the given reader
* @throws NullPointerException if the input parameter is null
* @see #buffer(Reader)
* @since 2.5
*/
public static BufferedReader toBufferedReader(final Reader reader, final int size) {
return reader instanceof BufferedReader ? (BufferedReader) reader : new BufferedReader(reader, size);
}
/**
* Gets the contents of an {@link InputStream} as a {@code byte[]}.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param inputStream the {@link InputStream} to read.
* @return the requested byte array.
* @throws NullPointerException if the InputStream is {@code null}.
* @throws IOException if an I/O error occurs or reading more than {@link Integer#MAX_VALUE} occurs.
*/
public static byte[] toByteArray(final InputStream inputStream) throws IOException {
// We use a ThresholdingOutputStream to avoid reading AND writing more than Integer.MAX_VALUE.
try (UnsynchronizedByteArrayOutputStream ubaOutput = UnsynchronizedByteArrayOutputStream.builder().get();
ThresholdingOutputStream thresholdOutput = new ThresholdingOutputStream(Integer.MAX_VALUE, os -> {
throw new IllegalArgumentException(String.format("Cannot read more than %,d into a byte array", Integer.MAX_VALUE));
}, os -> ubaOutput)) {
copy(inputStream, thresholdOutput);
return ubaOutput.toByteArray();
}
}
/**
* Gets the contents of an {@link InputStream} as a {@code byte[]}. Use this method instead of
* {@link #toByteArray(InputStream)} when {@link InputStream} size is known.
*
* @param input the {@link InputStream} to read.
* @param size the size of {@link InputStream} to read, where 0 < {@code size} <= length of input stream.
* @return byte [] of length {@code size}.
* @throws IOException if an I/O error occurs or {@link InputStream} length is smaller than parameter {@code size}.
* @throws IllegalArgumentException if {@code size} is less than zero.
* @since 2.1
*/
public static byte[] toByteArray(final InputStream input, final int size) throws IOException {
if (size == 0) {
return EMPTY_BYTE_ARRAY;
}
return toByteArray(Objects.requireNonNull(input, "input")::read, size);
}
/**
* Gets contents of an {@link InputStream} as a {@code byte[]}.
* Use this method instead of {@link #toByteArray(InputStream)}
* when {@link InputStream} size is known.
* NOTE: the method checks that the length can safely be cast to an int without truncation
* before using {@link IOUtils#toByteArray(InputStream, int)} to read into the byte array.
* (Arrays can have no more than Integer.MAX_VALUE entries anyway)
*
* @param input the {@link InputStream} to read
* @param size the size of {@link InputStream} to read, where 0 < {@code size} <= min(Integer.MAX_VALUE, length of input stream).
* @return byte [] the requested byte array, of length {@code size}
* @throws IOException if an I/O error occurs or {@link InputStream} length is less than {@code size}
* @throws IllegalArgumentException if size is less than zero or size is greater than Integer.MAX_VALUE
* @see IOUtils#toByteArray(InputStream, int)
* @since 2.1
*/
public static byte[] toByteArray(final InputStream input, final long size) throws IOException {
if (size > Integer.MAX_VALUE) {
throw new IllegalArgumentException("Size cannot be greater than Integer max value: " + size);
}
return toByteArray(input, (int) size);
}
/**
* Gets the contents of an input as a {@code byte[]}.
*
* @param input the input to read.
* @param size the size of the input to read, where 0 < {@code size} <= length of input.
* @return byte [] of length {@code size}.
* @throws IOException if an I/O error occurs or input length is smaller than parameter {@code size}.
* @throws IllegalArgumentException if {@code size} is less than zero.
*/
static byte[] toByteArray(final IOTriFunction input, final int size) throws IOException {
if (size < 0) {
throw new IllegalArgumentException("Size must be equal or greater than zero: " + size);
}
if (size == 0) {
return EMPTY_BYTE_ARRAY;
}
final byte[] data = byteArray(size);
int offset = 0;
int read;
while (offset < size && (read = input.apply(data, offset, size - offset)) != EOF) {
offset += read;
}
if (offset != size) {
throw new IOException("Unexpected read size, current: " + offset + ", expected: " + size);
}
return data;
}
/**
* Gets the contents of a {@link Reader} as a {@code byte[]}
* using the default character encoding of the platform.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* @param reader the {@link Reader} to read
* @return the requested byte array
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @deprecated Use {@link #toByteArray(Reader, Charset)} instead
*/
@Deprecated
public static byte[] toByteArray(final Reader reader) throws IOException {
return toByteArray(reader, Charset.defaultCharset());
}
/**
* Gets the contents of a {@link Reader} as a {@code byte[]}
* using the specified character encoding.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* @param reader the {@link Reader} to read
* @param charset the charset to use, null means platform default
* @return the requested byte array
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @since 2.3
*/
public static byte[] toByteArray(final Reader reader, final Charset charset) throws IOException {
try (ByteArrayOutputStream output = new ByteArrayOutputStream()) {
copy(reader, output, charset);
return output.toByteArray();
}
}
/**
* Gets the contents of a {@link Reader} as a {@code byte[]}
* using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* @param reader the {@link Reader} to read
* @param charsetName the name of the requested charset, null means platform default
* @return the requested byte array
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
*/
public static byte[] toByteArray(final Reader reader, final String charsetName) throws IOException {
return toByteArray(reader, Charsets.toCharset(charsetName));
}
/**
* Gets the contents of a {@link String} as a {@code byte[]}
* using the default character encoding of the platform.
*
* This is the same as {@link String#getBytes()}.
*
*
* @param input the {@link String} to convert
* @return the requested byte array
* @throws NullPointerException if the input is null
* @deprecated Use {@link String#getBytes()} instead
*/
@Deprecated
public static byte[] toByteArray(final String input) {
// make explicit the use of the default charset
return input.getBytes(Charset.defaultCharset());
}
/**
* Gets the contents of a {@link URI} as a {@code byte[]}.
*
* @param uri the {@link URI} to read
* @return the requested byte array
* @throws NullPointerException if the uri is null
* @throws IOException if an I/O exception occurs
* @since 2.4
*/
public static byte[] toByteArray(final URI uri) throws IOException {
return toByteArray(uri.toURL());
}
/**
* Gets the contents of a {@link URL} as a {@code byte[]}.
*
* @param url the {@link URL} to read
* @return the requested byte array
* @throws NullPointerException if the input is null
* @throws IOException if an I/O exception occurs
* @since 2.4
*/
public static byte[] toByteArray(final URL url) throws IOException {
try (CloseableURLConnection urlConnection = CloseableURLConnection.open(url)) {
return toByteArray(urlConnection);
}
}
/**
* Gets the contents of a {@link URLConnection} as a {@code byte[]}.
*
* @param urlConnection the {@link URLConnection} to read.
* @return the requested byte array.
* @throws NullPointerException if the urlConn is null.
* @throws IOException if an I/O exception occurs.
* @since 2.4
*/
public static byte[] toByteArray(final URLConnection urlConnection) throws IOException {
try (InputStream inputStream = urlConnection.getInputStream()) {
return toByteArray(inputStream);
}
}
/**
* Gets the contents of an {@link InputStream} as a character array
* using the default character encoding of the platform.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param inputStream the {@link InputStream} to read
* @return the requested character array
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @since 1.1
* @deprecated Use {@link #toCharArray(InputStream, Charset)} instead
*/
@Deprecated
public static char[] toCharArray(final InputStream inputStream) throws IOException {
return toCharArray(inputStream, Charset.defaultCharset());
}
/**
* Gets the contents of an {@link InputStream} as a character array
* using the specified character encoding.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param inputStream the {@link InputStream} to read
* @param charset the charset to use, null means platform default
* @return the requested character array
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @since 2.3
*/
public static char[] toCharArray(final InputStream inputStream, final Charset charset)
throws IOException {
final CharArrayWriter writer = new CharArrayWriter();
copy(inputStream, writer, charset);
return writer.toCharArray();
}
/**
* Gets the contents of an {@link InputStream} as a character array
* using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param inputStream the {@link InputStream} to read
* @param charsetName the name of the requested charset, null means platform default
* @return the requested character array
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
*/
public static char[] toCharArray(final InputStream inputStream, final String charsetName) throws IOException {
return toCharArray(inputStream, Charsets.toCharset(charsetName));
}
/**
* Gets the contents of a {@link Reader} as a character array.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* @param reader the {@link Reader} to read
* @return the requested character array
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @since 1.1
*/
public static char[] toCharArray(final Reader reader) throws IOException {
final CharArrayWriter sw = new CharArrayWriter();
copy(reader, sw);
return sw.toCharArray();
}
/**
* Converts the specified CharSequence to an input stream, encoded as bytes
* using the default character encoding of the platform.
*
* @param input the CharSequence to convert
* @return an input stream
* @since 2.0
* @deprecated Use {@link #toInputStream(CharSequence, Charset)} instead
*/
@Deprecated
public static InputStream toInputStream(final CharSequence input) {
return toInputStream(input, Charset.defaultCharset());
}
/**
* Converts the specified CharSequence to an input stream, encoded as bytes
* using the specified character encoding.
*
* @param input the CharSequence to convert
* @param charset the charset to use, null means platform default
* @return an input stream
* @since 2.3
*/
public static InputStream toInputStream(final CharSequence input, final Charset charset) {
return toInputStream(input.toString(), charset);
}
/**
* Converts the specified CharSequence to an input stream, encoded as bytes
* using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* @param input the CharSequence to convert
* @param charsetName the name of the requested charset, null means platform default
* @return an input stream
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 2.0
*/
public static InputStream toInputStream(final CharSequence input, final String charsetName) {
return toInputStream(input, Charsets.toCharset(charsetName));
}
/**
* Converts the specified string to an input stream, encoded as bytes
* using the default character encoding of the platform.
*
* @param input the string to convert
* @return an input stream
* @since 1.1
* @deprecated Use {@link #toInputStream(String, Charset)} instead
*/
@Deprecated
public static InputStream toInputStream(final String input) {
return toInputStream(input, Charset.defaultCharset());
}
/**
* Converts the specified string to an input stream, encoded as bytes
* using the specified character encoding.
*
* @param input the string to convert
* @param charset the charset to use, null means platform default
* @return an input stream
* @since 2.3
*/
public static InputStream toInputStream(final String input, final Charset charset) {
return new ByteArrayInputStream(input.getBytes(Charsets.toCharset(charset)));
}
/**
* Converts the specified string to an input stream, encoded as bytes
* using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* @param input the string to convert
* @param charsetName the name of the requested charset, null means platform default
* @return an input stream
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
*/
public static InputStream toInputStream(final String input, final String charsetName) {
return new ByteArrayInputStream(input.getBytes(Charsets.toCharset(charsetName)));
}
/**
* Gets the contents of a {@code byte[]} as a String
* using the default character encoding of the platform.
*
* @param input the byte array to read
* @return the requested String
* @throws NullPointerException if the input is null
* @deprecated Use {@link String#String(byte[])} instead
*/
@Deprecated
public static String toString(final byte[] input) {
// make explicit the use of the default charset
return new String(input, Charset.defaultCharset());
}
/**
* Gets the contents of a {@code byte[]} as a String
* using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* @param input the byte array to read
* @param charsetName the name of the requested charset, null means platform default
* @return the requested String
* @throws NullPointerException if the input is null
*/
public static String toString(final byte[] input, final String charsetName) {
return new String(input, Charsets.toCharset(charsetName));
}
/**
* Gets the contents of an {@link InputStream} as a String
* using the default character encoding of the platform.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param input the {@link InputStream} to read
* @return the requested String
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @deprecated Use {@link #toString(InputStream, Charset)} instead
*/
@Deprecated
public static String toString(final InputStream input) throws IOException {
return toString(input, Charset.defaultCharset());
}
/**
* Gets the contents of an {@link InputStream} as a String
* using the specified character encoding.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param input the {@link InputStream} to read
* @param charset the charset to use, null means platform default
* @return the requested String
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @since 2.3
*/
public static String toString(final InputStream input, final Charset charset) throws IOException {
try (StringBuilderWriter sw = new StringBuilderWriter()) {
copy(input, sw, charset);
return sw.toString();
}
}
/**
* Gets the contents of an {@link InputStream} as a String
* using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param input the {@link InputStream} to read
* @param charsetName the name of the requested charset, null means platform default
* @return the requested String
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
*/
public static String toString(final InputStream input, final String charsetName)
throws IOException {
return toString(input, Charsets.toCharset(charsetName));
}
/**
* Gets the contents of an {@link InputStream} from a supplier as a String
* using the specified character encoding.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param input supplies the {@link InputStream} to read
* @param charset the charset to use, null means platform default
* @return the requested String
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @since 2.12.0
*/
public static String toString(final IOSupplier input, final Charset charset) throws IOException {
return toString(input, charset, () -> {
throw new NullPointerException("input");
});
}
/**
* Gets the contents of an {@link InputStream} from a supplier as a String
* using the specified character encoding.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedInputStream}.
*
*
* @param input supplies the {@link InputStream} to read
* @param charset the charset to use, null means platform default
* @param defaultString the default return value if the supplier or its value is null.
* @return the requested String
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @since 2.12.0
*/
public static String toString(final IOSupplier input, final Charset charset, final IOSupplier defaultString) throws IOException {
if (input == null) {
return defaultString.get();
}
try (InputStream inputStream = input.get()) {
return inputStream != null ? toString(inputStream, charset) : defaultString.get();
}
}
/**
* Gets the contents of a {@link Reader} as a String.
*
* This method buffers the input internally, so there is no need to use a
* {@link BufferedReader}.
*
*
* @param reader the {@link Reader} to read
* @return the requested String
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
*/
public static String toString(final Reader reader) throws IOException {
try (StringBuilderWriter sw = new StringBuilderWriter()) {
copy(reader, sw);
return sw.toString();
}
}
/**
* Gets the contents at the given URI.
*
* @param uri The URI source.
* @return The contents of the URL as a String.
* @throws IOException if an I/O exception occurs.
* @since 2.1
* @deprecated Use {@link #toString(URI, Charset)} instead
*/
@Deprecated
public static String toString(final URI uri) throws IOException {
return toString(uri, Charset.defaultCharset());
}
/**
* Gets the contents at the given URI.
*
* @param uri The URI source.
* @param encoding The encoding name for the URL contents.
* @return The contents of the URL as a String.
* @throws IOException if an I/O exception occurs.
* @since 2.3.
*/
public static String toString(final URI uri, final Charset encoding) throws IOException {
return toString(uri.toURL(), Charsets.toCharset(encoding));
}
/**
* Gets the contents at the given URI.
*
* @param uri The URI source.
* @param charsetName The encoding name for the URL contents.
* @return The contents of the URL as a String.
* @throws IOException if an I/O exception occurs.
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 2.1
*/
public static String toString(final URI uri, final String charsetName) throws IOException {
return toString(uri, Charsets.toCharset(charsetName));
}
/**
* Gets the contents at the given URL.
*
* @param url The URL source.
* @return The contents of the URL as a String.
* @throws IOException if an I/O exception occurs.
* @since 2.1
* @deprecated Use {@link #toString(URL, Charset)} instead
*/
@Deprecated
public static String toString(final URL url) throws IOException {
return toString(url, Charset.defaultCharset());
}
/**
* Gets the contents at the given URL.
*
* @param url The URL source.
* @param encoding The encoding name for the URL contents.
* @return The contents of the URL as a String.
* @throws IOException if an I/O exception occurs.
* @since 2.3
*/
public static String toString(final URL url, final Charset encoding) throws IOException {
return toString(url::openStream, encoding);
}
/**
* Gets the contents at the given URL.
*
* @param url The URL source.
* @param charsetName The encoding name for the URL contents.
* @return The contents of the URL as a String.
* @throws IOException if an I/O exception occurs.
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 2.1
*/
public static String toString(final URL url, final String charsetName) throws IOException {
return toString(url, Charsets.toCharset(charsetName));
}
/**
* Writes bytes from a {@code byte[]} to an {@link OutputStream}.
*
* @param data the byte array to write, do not modify during output,
* null ignored
* @param output the {@link OutputStream} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 1.1
*/
public static void write(final byte[] data, final OutputStream output)
throws IOException {
if (data != null) {
output.write(data);
}
}
/**
* Writes bytes from a {@code byte[]} to chars on a {@link Writer}
* using the default character encoding of the platform.
*
* This method uses {@link String#String(byte[])}.
*
*
* @param data the byte array to write, do not modify during output,
* null ignored
* @param writer the {@link Writer} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 1.1
* @deprecated Use {@link #write(byte[], Writer, Charset)} instead
*/
@Deprecated
public static void write(final byte[] data, final Writer writer) throws IOException {
write(data, writer, Charset.defaultCharset());
}
/**
* Writes bytes from a {@code byte[]} to chars on a {@link Writer}
* using the specified character encoding.
*
* This method uses {@link String#String(byte[], String)}.
*
*
* @param data the byte array to write, do not modify during output,
* null ignored
* @param writer the {@link Writer} to write to
* @param charset the charset to use, null means platform default
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 2.3
*/
public static void write(final byte[] data, final Writer writer, final Charset charset) throws IOException {
if (data != null) {
writer.write(new String(data, Charsets.toCharset(charset)));
}
}
/**
* Writes bytes from a {@code byte[]} to chars on a {@link Writer}
* using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* This method uses {@link String#String(byte[], String)}.
*
*
* @param data the byte array to write, do not modify during output,
* null ignored
* @param writer the {@link Writer} to write to
* @param charsetName the name of the requested charset, null means platform default
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
*/
public static void write(final byte[] data, final Writer writer, final String charsetName) throws IOException {
write(data, writer, Charsets.toCharset(charsetName));
}
/**
* Writes chars from a {@code char[]} to bytes on an
* {@link OutputStream}.
*
* This method uses {@link String#String(char[])} and
* {@link String#getBytes()}.
*
*
* @param data the char array to write, do not modify during output,
* null ignored
* @param output the {@link OutputStream} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 1.1
* @deprecated Use {@link #write(char[], OutputStream, Charset)} instead
*/
@Deprecated
public static void write(final char[] data, final OutputStream output)
throws IOException {
write(data, output, Charset.defaultCharset());
}
/**
* Writes chars from a {@code char[]} to bytes on an
* {@link OutputStream} using the specified character encoding.
*
* This method uses {@link String#String(char[])} and
* {@link String#getBytes(String)}.
*
*
* @param data the char array to write, do not modify during output,
* null ignored
* @param output the {@link OutputStream} to write to
* @param charset the charset to use, null means platform default
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 2.3
*/
public static void write(final char[] data, final OutputStream output, final Charset charset) throws IOException {
if (data != null) {
write(new String(data), output, charset);
}
}
/**
* Writes chars from a {@code char[]} to bytes on an
* {@link OutputStream} using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* This method uses {@link String#String(char[])} and
* {@link String#getBytes(String)}.
*
*
* @param data the char array to write, do not modify during output,
* null ignored
* @param output the {@link OutputStream} to write to
* @param charsetName the name of the requested charset, null means platform default
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
*/
public static void write(final char[] data, final OutputStream output, final String charsetName)
throws IOException {
write(data, output, Charsets.toCharset(charsetName));
}
/**
* Writes chars from a {@code char[]} to a {@link Writer}
*
* @param data the char array to write, do not modify during output,
* null ignored
* @param writer the {@link Writer} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 1.1
*/
public static void write(final char[] data, final Writer writer) throws IOException {
if (data != null) {
writer.write(data);
}
}
/**
* Writes chars from a {@link CharSequence} to bytes on an
* {@link OutputStream} using the default character encoding of the
* platform.
*
* This method uses {@link String#getBytes()}.
*
*
* @param data the {@link CharSequence} to write, null ignored
* @param output the {@link OutputStream} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 2.0
* @deprecated Use {@link #write(CharSequence, OutputStream, Charset)} instead
*/
@Deprecated
public static void write(final CharSequence data, final OutputStream output)
throws IOException {
write(data, output, Charset.defaultCharset());
}
/**
* Writes chars from a {@link CharSequence} to bytes on an
* {@link OutputStream} using the specified character encoding.
*
* This method uses {@link String#getBytes(String)}.
*
*
* @param data the {@link CharSequence} to write, null ignored
* @param output the {@link OutputStream} to write to
* @param charset the charset to use, null means platform default
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 2.3
*/
public static void write(final CharSequence data, final OutputStream output, final Charset charset)
throws IOException {
if (data != null) {
write(data.toString(), output, charset);
}
}
/**
* Writes chars from a {@link CharSequence} to bytes on an
* {@link OutputStream} using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* This method uses {@link String#getBytes(String)}.
*
*
* @param data the {@link CharSequence} to write, null ignored
* @param output the {@link OutputStream} to write to
* @param charsetName the name of the requested charset, null means platform default
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 2.0
*/
public static void write(final CharSequence data, final OutputStream output, final String charsetName)
throws IOException {
write(data, output, Charsets.toCharset(charsetName));
}
/**
* Writes chars from a {@link CharSequence} to a {@link Writer}.
*
* @param data the {@link CharSequence} to write, null ignored
* @param writer the {@link Writer} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 2.0
*/
public static void write(final CharSequence data, final Writer writer) throws IOException {
if (data != null) {
write(data.toString(), writer);
}
}
/**
* Writes chars from a {@link String} to bytes on an
* {@link OutputStream} using the default character encoding of the
* platform.
*
* This method uses {@link String#getBytes()}.
*
*
* @param data the {@link String} to write, null ignored
* @param output the {@link OutputStream} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 1.1
* @deprecated Use {@link #write(String, OutputStream, Charset)} instead
*/
@Deprecated
public static void write(final String data, final OutputStream output)
throws IOException {
write(data, output, Charset.defaultCharset());
}
/**
* Writes chars from a {@link String} to bytes on an
* {@link OutputStream} using the specified character encoding.
*
* This method uses {@link String#getBytes(String)}.
*
*
* @param data the {@link String} to write, null ignored
* @param output the {@link OutputStream} to write to
* @param charset the charset to use, null means platform default
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 2.3
*/
@SuppressWarnings("resource")
public static void write(final String data, final OutputStream output, final Charset charset) throws IOException {
if (data != null) {
// Use Charset#encode(String), since calling String#getBytes(Charset) might result in
// NegativeArraySizeException or OutOfMemoryError.
// The underlying OutputStream should not be closed, so the channel is not closed.
Channels.newChannel(output).write(Charsets.toCharset(charset).encode(data));
}
}
/**
* Writes chars from a {@link String} to bytes on an
* {@link OutputStream} using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* This method uses {@link String#getBytes(String)}.
*
*
* @param data the {@link String} to write, null ignored
* @param output the {@link OutputStream} to write to
* @param charsetName the name of the requested charset, null means platform default
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
*/
public static void write(final String data, final OutputStream output, final String charsetName)
throws IOException {
write(data, output, Charsets.toCharset(charsetName));
}
/**
* Writes chars from a {@link String} to a {@link Writer}.
*
* @param data the {@link String} to write, null ignored
* @param writer the {@link Writer} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 1.1
*/
public static void write(final String data, final Writer writer) throws IOException {
if (data != null) {
writer.write(data);
}
}
/**
* Writes chars from a {@link StringBuffer} to bytes on an
* {@link OutputStream} using the default character encoding of the
* platform.
*
* This method uses {@link String#getBytes()}.
*
*
* @param data the {@link StringBuffer} to write, null ignored
* @param output the {@link OutputStream} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 1.1
* @deprecated Use {@link #write(CharSequence, OutputStream)}
*/
@Deprecated
public static void write(final StringBuffer data, final OutputStream output) //NOSONAR
throws IOException {
write(data, output, (String) null);
}
/**
* Writes chars from a {@link StringBuffer} to bytes on an
* {@link OutputStream} using the specified character encoding.
*
* Character encoding names can be found at
* IANA.
*
*
* This method uses {@link String#getBytes(String)}.
*
*
* @param data the {@link StringBuffer} to write, null ignored
* @param output the {@link OutputStream} to write to
* @param charsetName the name of the requested charset, null means platform default
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
* @deprecated Use {@link #write(CharSequence, OutputStream, String)}.
*/
@Deprecated
public static void write(final StringBuffer data, final OutputStream output, final String charsetName) //NOSONAR
throws IOException {
if (data != null) {
write(data.toString(), output, Charsets.toCharset(charsetName));
}
}
/**
* Writes chars from a {@link StringBuffer} to a {@link Writer}.
*
* @param data the {@link StringBuffer} to write, null ignored
* @param writer the {@link Writer} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 1.1
* @deprecated Use {@link #write(CharSequence, Writer)}
*/
@Deprecated
public static void write(final StringBuffer data, final Writer writer) //NOSONAR
throws IOException {
if (data != null) {
writer.write(data.toString());
}
}
/**
* Writes bytes from a {@code byte[]} to an {@link OutputStream} using chunked writes.
* This is intended for writing very large byte arrays which might otherwise cause excessive
* memory usage if the native code has to allocate a copy.
*
* @param data the byte array to write, do not modify during output,
* null ignored
* @param output the {@link OutputStream} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 2.5
*/
public static void writeChunked(final byte[] data, final OutputStream output)
throws IOException {
if (data != null) {
int bytes = data.length;
int offset = 0;
while (bytes > 0) {
final int chunk = Math.min(bytes, DEFAULT_BUFFER_SIZE);
output.write(data, offset, chunk);
bytes -= chunk;
offset += chunk;
}
}
}
/**
* Writes chars from a {@code char[]} to a {@link Writer} using chunked writes.
* This is intended for writing very large byte arrays which might otherwise cause excessive
* memory usage if the native code has to allocate a copy.
*
* @param data the char array to write, do not modify during output,
* null ignored
* @param writer the {@link Writer} to write to
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 2.5
*/
public static void writeChunked(final char[] data, final Writer writer) throws IOException {
if (data != null) {
int bytes = data.length;
int offset = 0;
while (bytes > 0) {
final int chunk = Math.min(bytes, DEFAULT_BUFFER_SIZE);
writer.write(data, offset, chunk);
bytes -= chunk;
offset += chunk;
}
}
}
/**
* Writes the {@link #toString()} value of each item in a collection to
* an {@link OutputStream} line by line, using the default character
* encoding of the platform and the specified line ending.
*
* @param lines the lines to write, null entries produce blank lines
* @param lineEnding the line separator to use, null is system default
* @param output the {@link OutputStream} to write to, not null, not closed
* @throws NullPointerException if the output is null
* @throws IOException if an I/O error occurs
* @since 1.1
* @deprecated Use {@link #writeLines(Collection, String, OutputStream, Charset)} instead
*/
@Deprecated
public static void writeLines(final Collection lines, final String lineEnding,
final OutputStream output) throws IOException {
writeLines(lines, lineEnding, output, Charset.defaultCharset());
}
/**
* Writes the {@link #toString()} value of each item in a collection to
* an {@link OutputStream} line by line, using the specified character
* encoding and the specified line ending.
*
* UTF-16 is written big-endian with no byte order mark.
* For little-endian, use UTF-16LE. For a BOM, write it to the stream
* before calling this method.
*
*
* @param lines the lines to write, null entries produce blank lines
* @param lineEnding the line separator to use, null is system default
* @param output the {@link OutputStream} to write to, not null, not closed
* @param charset the charset to use, null means platform default
* @throws NullPointerException if output is null
* @throws IOException if an I/O error occurs
* @since 2.3
*/
public static void writeLines(final Collection lines, String lineEnding, final OutputStream output,
Charset charset) throws IOException {
if (lines == null) {
return;
}
if (lineEnding == null) {
lineEnding = System.lineSeparator();
}
if (StandardCharsets.UTF_16.equals(charset)) {
// don't write a BOM
charset = StandardCharsets.UTF_16BE;
}
final byte[] eolBytes = lineEnding.getBytes(charset);
for (final Object line : lines) {
if (line != null) {
write(line.toString(), output, charset);
}
output.write(eolBytes);
}
}
/**
* Writes the {@link #toString()} value of each item in a collection to
* an {@link OutputStream} line by line, using the specified character
* encoding and the specified line ending.
*
* Character encoding names can be found at
* IANA.
*
*
* @param lines the lines to write, null entries produce blank lines
* @param lineEnding the line separator to use, null is system default
* @param output the {@link OutputStream} to write to, not null, not closed
* @param charsetName the name of the requested charset, null means platform default
* @throws NullPointerException if the output is null
* @throws IOException if an I/O error occurs
* @throws java.nio.charset.UnsupportedCharsetException if the encoding is not supported
* @since 1.1
*/
public static void writeLines(final Collection lines, final String lineEnding,
final OutputStream output, final String charsetName) throws IOException {
writeLines(lines, lineEnding, output, Charsets.toCharset(charsetName));
}
/**
* Writes the {@link #toString()} value of each item in a collection to
* a {@link Writer} line by line, using the specified line ending.
*
* @param lines the lines to write, null entries produce blank lines
* @param lineEnding the line separator to use, null is system default
* @param writer the {@link Writer} to write to, not null, not closed
* @throws NullPointerException if the input is null
* @throws IOException if an I/O error occurs
* @since 1.1
*/
public static void writeLines(final Collection lines, String lineEnding,
final Writer writer) throws IOException {
if (lines == null) {
return;
}
if (lineEnding == null) {
lineEnding = System.lineSeparator();
}
for (final Object line : lines) {
if (line != null) {
writer.write(line.toString());
}
writer.write(lineEnding);
}
}
/**
* Returns the given Appendable if it is already a {@link Writer}, otherwise creates a Writer wrapper around the
* given Appendable.
*
* @param appendable the Appendable to wrap or return (not null)
* @return the given Appendable or a Writer wrapper around the given Appendable
* @throws NullPointerException if the input parameter is null
* @since 2.7
*/
public static Writer writer(final Appendable appendable) {
Objects.requireNonNull(appendable, "appendable");
if (appendable instanceof Writer) {
return (Writer) appendable;
}
if (appendable instanceof StringBuilder) {
return new StringBuilderWriter((StringBuilder) appendable);
}
return new AppendableWriter<>(appendable);
}
/**
* Instances should NOT be constructed in standard programming.
*
* @deprecated TODO Make private in 3.0.
*/
@Deprecated
public IOUtils() { //NOSONAR
// empty
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/LineIterator.java 0100644 0000000 0000000 00000013566 14603604450 027014 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.Reader;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;
/**
* An Iterator over the lines in a {@link Reader}.
*
* {@link LineIterator} holds a reference to an open {@link Reader}.
* When you have finished with the iterator you should close the reader
* to free internal resources. This can be done by closing the reader directly,
* or by calling the {@link #close()} or {@link #closeQuietly(LineIterator)}
* method on the iterator.
*
* The recommended usage pattern is:
*
* LineIterator it = FileUtils.lineIterator(file, StandardCharsets.UTF_8.name());
* try {
* while (it.hasNext()) {
* String line = it.nextLine();
* // do something with line
* }
* } finally {
* it.close();
* }
*
*
* @since 1.2
*/
public class LineIterator implements Iterator, Closeable {
// N.B. This class deliberately does not implement Iterable, see https://issues.apache.org/jira/browse/IO-181
/**
* Closes a {@link LineIterator} quietly.
*
* @param iterator The iterator to close, or {@code null}.
* @deprecated As of 2.6 deprecated without replacement. Please use the try-with-resources statement or handle
* suppressed exceptions manually.
* @see Throwable#addSuppressed(Throwable)
*/
@Deprecated
public static void closeQuietly(final LineIterator iterator) {
IOUtils.closeQuietly(iterator);
}
/** The reader that is being read. */
private final BufferedReader bufferedReader;
/** The current line. */
private String cachedLine;
/** A flag indicating if the iterator has been fully read. */
private boolean finished;
/**
* Constructs an iterator of the lines for a {@link Reader}.
*
* @param reader the {@link Reader} to read from, not null
* @throws NullPointerException if the reader is null
*/
@SuppressWarnings("resource") // Caller closes Reader
public LineIterator(final Reader reader) {
Objects.requireNonNull(reader, "reader");
if (reader instanceof BufferedReader) {
bufferedReader = (BufferedReader) reader;
} else {
bufferedReader = new BufferedReader(reader);
}
}
/**
* Closes the underlying {@link Reader}.
* This method is useful if you only want to process the first few
* lines of a larger file. If you do not close the iterator
* then the {@link Reader} remains open.
* This method can safely be called multiple times.
*
* @throws IOException if closing the underlying {@link Reader} fails.
*/
@Override
public void close() throws IOException {
finished = true;
cachedLine = null;
IOUtils.close(bufferedReader);
}
/**
* Indicates whether the {@link Reader} has more lines.
* If there is an {@link IOException} then {@link #close()} will
* be called on this instance.
*
* @return {@code true} if the Reader has more lines
* @throws IllegalStateException if an IO exception occurs
*/
@Override
public boolean hasNext() {
if (cachedLine != null) {
return true;
}
if (finished) {
return false;
}
try {
while (true) {
final String line = bufferedReader.readLine();
if (line == null) {
finished = true;
return false;
}
if (isValidLine(line)) {
cachedLine = line;
return true;
}
}
} catch (final IOException ioe) {
IOUtils.closeQuietly(this, ioe::addSuppressed);
throw new IllegalStateException(ioe);
}
}
/**
* Overridable method to validate each line that is returned.
* This implementation always returns true.
* @param line the line that is to be validated
* @return true if valid, false to remove from the iterator
*/
protected boolean isValidLine(final String line) {
return true;
}
/**
* Returns the next line in the wrapped {@link Reader}.
*
* @return the next line from the input
* @throws NoSuchElementException if there is no line to return
*/
@Override
public String next() {
return nextLine();
}
/**
* Returns the next line in the wrapped {@link Reader}.
*
* @return the next line from the input
* @throws NoSuchElementException if there is no line to return
*/
public String nextLine() {
if (!hasNext()) {
throw new NoSuchElementException("No more lines");
}
final String currentLine = cachedLine;
cachedLine = null;
return currentLine;
}
/**
* Unsupported.
*
* @throws UnsupportedOperationException always
*/
@Override
public void remove() {
throw new UnsupportedOperationException("remove not supported");
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/RandomAccessFileMode.java 0100644 0000000 0000000 00000006607 14603604450 030360 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.RandomAccessFile;
import java.nio.file.Path;
import java.util.Objects;
/**
* Access modes and factory methods for {@link RandomAccessFile}.
*
* @since 2.12.0
*/
public enum RandomAccessFileMode {
/**
* Mode {@code "r"} opens for reading only.
*/
READ_ONLY("r"),
/**
* Mode {@code "rw"} opens for reading and writing.
*/
READ_WRITE("rw"),
/**
* Mode {@code "rws"} opens for reading and writing, as with {@code "rw"}, and also require that every update to the file's content or metadata be written
* synchronously to the underlying storage device.
*/
READ_WRITE_SYNC_ALL("rws"),
/**
* Mode {@code "rwd"} open for reading and writing, as with {@code "rw"}, and also require that every update to the file's content be written synchronously
* to the underlying storage device.
*/
READ_WRITE_SYNC_CONTENT("rwd");
private final String mode;
RandomAccessFileMode(final String mode) {
this.mode = mode;
}
/**
* Constructs a random access file stream to read from, and optionally to write to, the file specified by the {@link File}
* argument.
*
* @param file the file object
* @return a random access file stream
* @throws FileNotFoundException See {@link RandomAccessFile#RandomAccessFile(File, String)}.
*/
public RandomAccessFile create(final File file) throws FileNotFoundException {
return new RandomAccessFile(file, mode);
}
/**
* Constructs a random access file stream to read from, and optionally to write to, the file specified by the {@link File}
* argument.
*
* @param file the file object
* @return a random access file stream
* @throws FileNotFoundException See {@link RandomAccessFile#RandomAccessFile(File, String)}.
*/
public RandomAccessFile create(final Path file) throws FileNotFoundException {
return create(Objects.requireNonNull(file.toFile(), "file"));
}
/**
* Constructs a random access file stream to read from, and optionally to write to, the file specified by the {@link File}
* argument.
*
* @param file the file object
* @return a random access file stream
* @throws FileNotFoundException See {@link RandomAccessFile#RandomAccessFile(File, String)}.
*/
public RandomAccessFile create(final String file) throws FileNotFoundException {
return new RandomAccessFile(file, mode);
}
@Override
public String toString() {
return mode;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/RandomAccessFiles.java 0100644 0000000 0000000 00000007465 14603604450 027741 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.util.Objects;
import org.apache.commons.io.channels.FileChannels;
/**
* Works with {@link RandomAccessFile}.
*
* @since 2.13.0
*/
public class RandomAccessFiles {
/**
* Tests if two RandomAccessFile contents are equal.
*
* @param raf1 A RandomAccessFile.
* @param raf2 Another RandomAccessFile.
* @return true if the contents of both RandomAccessFiles are equal, false otherwise.
* @throws IOException if an I/O error occurs.
* @since 2.15.0
*/
@SuppressWarnings("resource") // See comments
public static boolean contentEquals(final RandomAccessFile raf1, final RandomAccessFile raf2) throws IOException {
// Short-circuit test
if (Objects.equals(raf1, raf2)) {
return true;
}
// Short-circuit test
final long length1 = length(raf1);
final long length2 = length(raf2);
if (length1 != length2) {
return false;
}
if (length1 == 0 && length2 == 0) {
return true;
}
// Dig in and to the work
// We do not close FileChannels because that closes the owning RandomAccessFile.
// Instead, the caller is assumed to manage the given RandomAccessFile objects.
final FileChannel channel1 = raf1.getChannel();
final FileChannel channel2 = raf2.getChannel();
return FileChannels.contentEquals(channel1, channel2, IOUtils.DEFAULT_BUFFER_SIZE);
}
private static long length(final RandomAccessFile raf) throws IOException {
return raf != null ? raf.length() : 0;
}
/**
* Reads a byte array starting at "position" for "length" bytes.
*
* @param input The source RandomAccessFile.
* @param position The offset position, measured in bytes from the beginning of the file, at which to set the file pointer.
* @param length How many bytes to read.
* @return a new byte array.
* @throws IOException If the first byte cannot be read for any reason other than end of file, or if the random access file has been closed, or if some
* other I/O error occurs.
*/
public static byte[] read(final RandomAccessFile input, final long position, final int length) throws IOException {
input.seek(position);
return IOUtils.toByteArray(input::read, length);
}
/**
* Resets the given file to position 0.
*
* @param raf The RandomAccessFile to reset.
* @return The given RandomAccessFile.
* @throws IOException If {@code pos} is less than {@code 0} or if an I/O error occurs.
* @since 2.15.0
*/
public static RandomAccessFile reset(final RandomAccessFile raf) throws IOException {
raf.seek(0);
return raf;
}
/**
* Make private in 3.0.
*
* @deprecated TODO Make private in 3.0.
*/
@Deprecated
public RandomAccessFiles() {
// empty
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/StandardLineSeparator.java 0100644 0000000 0000000 00000004261 14603604450 030634 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.nio.charset.Charset;
import java.util.Objects;
/**
* Enumerates standard line separators: {@link #CR}, {@link #CRLF}, {@link #LF}.
*
* @since 2.9.0
*/
public enum StandardLineSeparator {
/**
* Carriage return. This is the line ending used on macOS 9 and earlier.
*/
CR("\r"),
/**
* Carriage return followed by line feed. This is the line ending used on Windows.
*/
CRLF("\r\n"),
/**
* Line feed. This is the line ending used on Linux and macOS X and later.
*/
LF("\n");
private final String lineSeparator;
/**
* Constructs a new instance for a non-null line separator.
*
* @param lineSeparator a non-null line separator.
*/
StandardLineSeparator(final String lineSeparator) {
this.lineSeparator = Objects.requireNonNull(lineSeparator, "lineSeparator");
}
/**
* Gets the bytes for this instance encoded using the given Charset.
*
* @param charset the encoding Charset.
* @return the bytes for this instance encoded using the given Charset.
*/
public byte[] getBytes(final Charset charset) {
return lineSeparator.getBytes(charset);
}
/**
* Gets the String value of this instance.
*
* @return the String value of this instance.
*/
public String getString() {
return lineSeparator;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/StreamIterator.java 0100644 0000000 0000000 00000006044 14603604450 027351 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.util.Iterator;
import java.util.Objects;
import java.util.stream.Stream;
/**
* Wraps and presents a {@link Stream} as a {@link AutoCloseable} {@link Iterator} resource that automatically closes itself when reaching the end of stream.
*
* Warning
*
* In order to close the stream, the call site MUST either close the stream it allocated OR call this iterator until the end.
*
*
* @param The {@link Stream} and {@link Iterator} type.
* @since 2.15.0
*/
public final class StreamIterator implements Iterator, AutoCloseable {
/**
* Wraps and presents a stream as a closable resource that automatically closes itself when reaching the end of stream.
*
* Warning
*
*
* In order to close the stream, the call site MUST either close the stream it allocated OR call this iterator until the end.
*
*
* @param The stream and iterator type.
* @param stream The stream iterate.
* @return A new iterator.
*/
public static StreamIterator iterator(final Stream stream) {
return new StreamIterator<>(stream);
}
/**
* The given stream's Iterator.
*/
private final Iterator iterator;
/**
* The given stream.
*/
private final Stream stream;
/**
* Whether {@link #close()} has been called.
*/
private boolean closed;
private StreamIterator(final Stream stream) {
this.stream = Objects.requireNonNull(stream, "stream");
this.iterator = stream.iterator();
}
/**
* Closes the underlying stream.
*/
@Override
public void close() {
closed = true;
stream.close();
}
@Override
public boolean hasNext() {
if (closed) {
// Calling Iterator#hasNext() on a closed java.nio.file.FileTreeIterator causes an IllegalStateException.
return false;
}
final boolean hasNext = iterator.hasNext();
if (!hasNext) {
close();
}
return hasNext;
}
@Override
public E next() {
final E next = iterator.next();
if (next == null) {
close();
}
return next;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/TaggedIOException.java 0100644 0000000 0000000 00000010766 14603604450 027714 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.IOException;
import java.io.Serializable;
/**
* An {@link IOException} decorator that adds a serializable tag to the
* wrapped exception. Both the tag and the original exception can be used
* to determine further processing when this exception is caught.
*
* @since 2.0
*/
@SuppressWarnings("deprecation") // needs to extend deprecated IOExceptionWithCause to preserve binary compatibility
public class TaggedIOException extends IOExceptionWithCause {
/**
* Generated serial version UID.
*/
private static final long serialVersionUID = -6994123481142850163L;
/**
* Checks whether the given throwable is tagged with the given tag.
*
* This check can only succeed if the throwable is a
* {@link TaggedIOException} and the tag is {@link Serializable}, but
* the argument types are intentionally more generic to make it easier
* to use this method without type casts.
*
* A typical use for this method is in a {@code catch} block to
* determine how a caught exception should be handled:
*
* Serializable tag = ...;
* try {
* ...;
* } catch (Throwable t) {
* if (TaggedIOException.isTaggedWith(t, tag)) {
* // special processing for tagged exception
* } else {
* // handling of other kinds of exceptions
* }
* }
*
*
* @param throwable The Throwable object to check
* @param tag tag object
* @return {@code true} if the throwable has the specified tag,
* otherwise {@code false}
*/
public static boolean isTaggedWith(final Throwable throwable, final Object tag) {
return tag != null
&& throwable instanceof TaggedIOException
&& tag.equals(((TaggedIOException) throwable).tag);
}
/**
* Throws the original {@link IOException} if the given throwable is
* a {@link TaggedIOException} decorator the given tag. Does nothing
* if the given throwable is of a different type or if it is tagged
* with some other tag.
*
* This method is typically used in a {@code catch} block to
* selectively rethrow tagged exceptions.
*
* Serializable tag = ...;
* try {
* ...;
* } catch (Throwable t) {
* TaggedIOException.throwCauseIfTagged(t, tag);
* // handle other kinds of exceptions
* }
*
*
* @param throwable an exception
* @param tag tag object
* @throws IOException original exception from the tagged decorator, if any
*/
public static void throwCauseIfTaggedWith(final Throwable throwable, final Object tag)
throws IOException {
if (isTaggedWith(throwable, tag)) {
throw ((TaggedIOException) throwable).getCause();
}
}
/**
* The tag of this exception.
*/
private final Serializable tag;
/**
* Constructs a tagged wrapper for the given exception.
*
* @param original the exception to be tagged
* @param tag tag of this exception
*/
public TaggedIOException(final IOException original, final Serializable tag) {
super(original.getMessage(), original);
this.tag = tag;
}
/**
* Returns the wrapped exception. The only difference to the overridden
* {@link Throwable#getCause()} method is the narrower return type.
*
* @return wrapped exception
*/
@Override
public synchronized IOException getCause() {
return (IOException) super.getCause();
}
/**
* Returns the serializable tag object.
*
* @return tag object
*/
public Serializable getTag() {
return tag;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/ThreadMonitor.java 0100644 0000000 0000000 00000006724 14603604450 027170 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.time.Duration;
/**
* Monitors a thread, interrupting it if it reaches the specified timeout.
*
* This works by sleeping until the specified timeout amount and then interrupting the thread being monitored. If the
* thread being monitored completes its work before being interrupted, it should {@code interrupt()} the monitor
* thread.
*
*
*
* Duration timeout = Duration.ofSeconds(1);
* try {
* Thread monitor = ThreadMonitor.start(timeout);
* // do some work here
* ThreadMonitor.stop(monitor);
* } catch (InterruptedException e) {
* // timed amount was reached
* }
*
*/
final class ThreadMonitor implements Runnable {
/**
* Starts monitoring the current thread.
*
* @param timeout The timeout amount. or no timeout if the value is zero or less.
* @return The monitor thread or {@code null} if the timeout amount is not greater than zero.
*/
static Thread start(final Duration timeout) {
return start(Thread.currentThread(), timeout);
}
/**
* Starts monitoring the specified thread.
*
* @param thread The thread to monitor
* @param timeout The timeout amount. or no timeout if the value is zero or less.
* @return The monitor thread or {@code null} if the timeout amount is not greater than zero.
*/
static Thread start(final Thread thread, final Duration timeout) {
if (timeout.isZero() || timeout.isNegative()) {
return null;
}
final Thread monitor = new Thread(new ThreadMonitor(thread, timeout), ThreadMonitor.class.getSimpleName());
monitor.setDaemon(true);
monitor.start();
return monitor;
}
/**
* Stops monitoring the specified thread.
*
* @param thread The monitor thread, may be {@code null}.
*/
static void stop(final Thread thread) {
if (thread != null) {
thread.interrupt();
}
}
private final Thread thread;
private final Duration timeout;
/**
* Constructs a new monitor.
*
* @param thread The thread to monitor.
* @param timeout The timeout amount.
*/
private ThreadMonitor(final Thread thread, final Duration timeout) {
this.thread = thread;
this.timeout = timeout;
}
/**
* Sleeps until the specified timeout amount and then interrupt the thread being monitored.
*
* @see Runnable#run()
*/
@Override
public void run() {
try {
ThreadUtils.sleep(timeout);
thread.interrupt();
} catch (final InterruptedException e) {
// timeout not reached
}
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/ThreadUtils.java 0100644 0000000 0000000 00000004345 14603604450 026636 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.time.Duration;
import java.time.Instant;
/**
* Helps work with threads.
*
* @since 2.12.0
*/
public final class ThreadUtils {
private static int getNanosOfMilli(final Duration duration) {
return duration.getNano() % 1_000_000;
}
/**
* Sleeps for a guaranteed minimum duration unless interrupted.
*
* This method exists because Thread.sleep(100) can sleep for 0, 70, 100 or 200ms or anything else it deems appropriate. Read
* {@link Thread#sleep(long, int)}} for further interesting details.
*
*
* @param duration the sleep duration.
* @throws InterruptedException if interrupted
* @see Thread#sleep(long, int)
*/
public static void sleep(final Duration duration) throws InterruptedException {
// Using this method avoids depending on the vagaries of the precision and accuracy of system timers and schedulers.
final Instant finishInstant = Instant.now().plus(duration);
Duration remainingDuration = duration;
do {
Thread.sleep(remainingDuration.toMillis(), getNanosOfMilli(remainingDuration));
remainingDuration = Duration.between(Instant.now(), finishInstant);
} while (!remainingDuration.isNegative());
}
/**
* Make private in 3.0.
*
* @deprecated TODO Make private in 3.0.
*/
@Deprecated
public ThreadUtils() {
// empty
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/UncheckedIOExceptions.java 0100644 0000000 0000000 00000004231 14603604450 030563 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.util.Objects;
/**
* Helps use lambdas that throw {@link IOException} rethrow as {@link UncheckedIOException}.
*
* @since 2.12.0
*/
final class UncheckedIOExceptions {
/**
* Constructs a new UncheckedIOException for the given detail message.
*
* This method exists because there is no String constructor in {@link UncheckedIOException}.
*
*
* @param message the detail message.
* @return a new {@link UncheckedIOException}.
*/
public static UncheckedIOException create(final Object message) {
final String string = Objects.toString(message);
return new UncheckedIOException(string, new IOException(string));
}
/**
* Constructs a new UncheckedIOException for the given detail message.
*
* This method exists because there is no String constructor in {@link UncheckedIOException}.
*
* @param e cause the {@link IOException}.
* @param message the detail message.
*
* @return a new {@link UncheckedIOException}.
*/
public static UncheckedIOException wrap(final IOException e, final Object message) {
return new UncheckedIOException(Objects.toString(message), e);
}
private UncheckedIOExceptions() {
// no instance
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/build/AbstractOrigin.java 0100644 0000000 0000000 00000046273 14603604450 030426 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.build;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.io.Writer;
import java.net.URI;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Objects;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.RandomAccessFileMode;
import org.apache.commons.io.RandomAccessFiles;
import org.apache.commons.io.input.CharSequenceInputStream;
import org.apache.commons.io.input.CharSequenceReader;
import org.apache.commons.io.input.ReaderInputStream;
import org.apache.commons.io.output.WriterOutputStream;
/**
* Abstracts the origin of data for builders like a {@link File}, {@link Path}, {@link Reader}, {@link Writer}, {@link InputStream}, {@link OutputStream}, and
* {@link URI}.
*
* Some methods may throw {@link UnsupportedOperationException} if that method is not implemented in a concrete subclass, see {@link #getFile()} and
* {@link #getPath()}.
*
*
* @param the type of instances to build.
* @param the type of builder subclass.
* @since 2.12.0
*/
public abstract class AbstractOrigin> extends AbstractSupplier {
/**
* A {@code byte[]} origin.
*/
public static class ByteArrayOrigin extends AbstractOrigin {
/**
* Constructs a new instance for the given origin.
*
* @param origin The origin.
*/
public ByteArrayOrigin(final byte[] origin) {
super(origin);
}
@Override
public byte[] getByteArray() {
// No conversion
return get();
}
/**
* {@inheritDoc}
*
* The {@code options} parameter is ignored since a {@code byte[]} does not need an {@link OpenOption} to be read.
*
*/
@Override
public InputStream getInputStream(final OpenOption... options) throws IOException {
return new ByteArrayInputStream(origin);
}
@Override
public Reader getReader(final Charset charset) throws IOException {
return new InputStreamReader(getInputStream(), charset);
}
@Override
public long size() throws IOException {
return origin.length;
}
}
/**
* A {@link CharSequence} origin.
*/
public static class CharSequenceOrigin extends AbstractOrigin {
/**
* Constructs a new instance for the given origin.
*
* @param origin The origin.
*/
public CharSequenceOrigin(final CharSequence origin) {
super(origin);
}
@Override
public byte[] getByteArray() {
// TODO Pass in a Charset? Consider if call sites actually need this.
return origin.toString().getBytes(Charset.defaultCharset());
}
/**
* {@inheritDoc}
*
* The {@code charset} parameter is ignored since a {@link CharSequence} does not need a {@link Charset} to be read.
*
*/
@Override
public CharSequence getCharSequence(final Charset charset) {
// No conversion
return get();
}
/**
* {@inheritDoc}
*
* The {@code options} parameter is ignored since a {@link CharSequence} does not need an {@link OpenOption} to be read.
*
*/
@Override
public InputStream getInputStream(final OpenOption... options) throws IOException {
// TODO Pass in a Charset? Consider if call sites actually need this.
return CharSequenceInputStream.builder().setCharSequence(getCharSequence(Charset.defaultCharset())).get();
}
/**
* {@inheritDoc}
*
* The {@code charset} parameter is ignored since a {@link CharSequence} does not need a {@link Charset} to be read.
*
*/
@Override
public Reader getReader(final Charset charset) throws IOException {
return new CharSequenceReader(get());
}
@Override
public long size() throws IOException {
return origin.length();
}
}
/**
* A {@link File} origin.
*
* Starting from this origin, you can get a byte array, a file, an input stream, an output stream, a path, a reader, and a writer.
*
*/
public static class FileOrigin extends AbstractOrigin {
/**
* Constructs a new instance for the given origin.
*
* @param origin The origin.
*/
public FileOrigin(final File origin) {
super(origin);
}
@Override
public byte[] getByteArray(final long position, final int length) throws IOException {
try (RandomAccessFile raf = RandomAccessFileMode.READ_ONLY.create(origin)) {
return RandomAccessFiles.read(raf, position, length);
}
}
@Override
public File getFile() {
// No conversion
return get();
}
@Override
public Path getPath() {
return get().toPath();
}
}
/**
* An {@link InputStream} origin.
*
* This origin cannot provide some of the other aspects.
*
*/
public static class InputStreamOrigin extends AbstractOrigin {
/**
* Constructs a new instance for the given origin.
*
* @param origin The origin.
*/
public InputStreamOrigin(final InputStream origin) {
super(origin);
}
@Override
public byte[] getByteArray() throws IOException {
return IOUtils.toByteArray(origin);
}
/**
* {@inheritDoc}
*
* The {@code options} parameter is ignored since a {@link InputStream} does not need an {@link OpenOption} to be read.
*
*/
@Override
public InputStream getInputStream(final OpenOption... options) {
// No conversion
return get();
}
@Override
public Reader getReader(final Charset charset) throws IOException {
return new InputStreamReader(getInputStream(), charset);
}
}
/**
* An {@link OutputStream} origin.
*
* This origin cannot provide some of the other aspects.
*
*/
public static class OutputStreamOrigin extends AbstractOrigin {
/**
* Constructs a new instance for the given origin.
*
* @param origin The origin.
*/
public OutputStreamOrigin(final OutputStream origin) {
super(origin);
}
/**
* {@inheritDoc}
*
* The {@code options} parameter is ignored since a {@link OutputStream} does not need an {@link OpenOption} to be written.
*
*/
@Override
public OutputStream getOutputStream(final OpenOption... options) {
// No conversion
return get();
}
/**
* {@inheritDoc}
*
* The {@code options} parameter is ignored since a {@link OutputStream} does not need an {@link OpenOption} to be written.
*
*/
@Override
public Writer getWriter(final Charset charset, final OpenOption... options) throws IOException {
return new OutputStreamWriter(origin, charset);
}
}
/**
* A {@link Path} origin.
*
* Starting from this origin, you can get a byte array, a file, an input stream, an output stream, a path, a reader, and a writer.
*
*/
public static class PathOrigin extends AbstractOrigin {
/**
* Constructs a new instance for the given origin.
*
* @param origin The origin.
*/
public PathOrigin(final Path origin) {
super(origin);
}
@Override
public byte[] getByteArray(final long position, final int length) throws IOException {
try (RandomAccessFile raf = RandomAccessFileMode.READ_ONLY.create(origin)) {
return RandomAccessFiles.read(raf, position, length);
}
}
@Override
public File getFile() {
return get().toFile();
}
@Override
public Path getPath() {
// No conversion
return get();
}
}
/**
* An {@link Reader} origin.
*
* This origin cannot provide other aspects.
*
*/
public static class ReaderOrigin extends AbstractOrigin {
/**
* Constructs a new instance for the given origin.
*
* @param origin The origin.
*/
public ReaderOrigin(final Reader origin) {
super(origin);
}
@Override
public byte[] getByteArray() throws IOException {
// TODO Pass in a Charset? Consider if call sites actually need this.
return IOUtils.toByteArray(origin, Charset.defaultCharset());
}
/**
* {@inheritDoc}
*
* The {@code charset} parameter is ignored since a {@link Reader} does not need a {@link Charset} to be read.
*
*/
@Override
public CharSequence getCharSequence(final Charset charset) throws IOException {
return IOUtils.toString(origin);
}
/**
* {@inheritDoc}
*
* The {@code options} parameter is ignored since a {@link Reader} does not need an {@link OpenOption} to be read.
*
*/
@Override
public InputStream getInputStream(final OpenOption... options) throws IOException {
// TODO Pass in a Charset? Consider if call sites actually need this.
return ReaderInputStream.builder().setReader(origin).setCharset(Charset.defaultCharset()).get();
}
/**
* {@inheritDoc}
*
* The {@code charset} parameter is ignored since a {@link Reader} does not need a {@link Charset} to be read.
*
*/
@Override
public Reader getReader(final Charset charset) throws IOException {
// No conversion
return get();
}
}
/**
* A {@link URI} origin.
*/
public static class URIOrigin extends AbstractOrigin {
/**
* Constructs a new instance for the given origin.
*
* @param origin The origin.
*/
public URIOrigin(final URI origin) {
super(origin);
}
@Override
public File getFile() {
return getPath().toFile();
}
@Override
public Path getPath() {
return Paths.get(get());
}
}
/**
* An {@link Writer} origin.
*
* This origin cannot provide other aspects.
*
*/
public static class WriterOrigin extends AbstractOrigin {
/**
* Constructs a new instance for the given origin.
*
* @param origin The origin.
*/
public WriterOrigin(final Writer origin) {
super(origin);
}
/**
* {@inheritDoc}
*
* The {@code options} parameter is ignored since a {@link Writer} does not need an {@link OpenOption} to be written.
*
*/
@Override
public OutputStream getOutputStream(final OpenOption... options) throws IOException {
// TODO Pass in a Charset? Consider if call sites actually need this.
return WriterOutputStream.builder().setWriter(origin).setCharset(Charset.defaultCharset()).get();
}
/**
* {@inheritDoc}
*
* The {@code charset} parameter is ignored since a {@link Writer} does not need a {@link Charset} to be written.
*
*
* The {@code options} parameter is ignored since a {@link Writer} does not need an {@link OpenOption} to be written.
*
*/
@Override
public Writer getWriter(final Charset charset, final OpenOption... options) throws IOException {
// No conversion
return get();
}
}
/**
* The non-null origin.
*/
final T origin;
/**
* Constructs a new instance for a subclass.
*
* @param origin The origin.
*/
protected AbstractOrigin(final T origin) {
this.origin = Objects.requireNonNull(origin, "origin");
}
/**
* Gets the origin.
*
* @return the origin.
*/
@Override
public T get() {
return origin;
}
/**
* Gets this origin as a byte array, if possible.
*
* @return this origin as a byte array, if possible.
* @throws IOException if an I/O error occurs.
* @throws UnsupportedOperationException if the origin cannot be converted to a Path.
*/
public byte[] getByteArray() throws IOException {
return Files.readAllBytes(getPath());
}
/**
* Gets this origin as a byte array, if possible.
*
* @param position the initial index of the range to be copied, inclusive.
* @param length How many bytes to copy.
* @return this origin as a byte array, if possible.
* @throws UnsupportedOperationException if the origin cannot be converted to a Path.
* @throws ArithmeticException if the {@code position} overflows an int
* @throws IOException if an I/O error occurs.
* @since 2.13.0
*/
public byte[] getByteArray(final long position, final int length) throws IOException {
final byte[] bytes = getByteArray();
// Checks for int overflow.
final int start = Math.toIntExact(position);
if (start < 0 || length < 0 || start + length < 0 || start + length > bytes.length) {
throw new IllegalArgumentException("Couldn't read array (start: " + start + ", length: " + length + ", data length: " + bytes.length + ").");
}
return Arrays.copyOfRange(bytes, start, start + length);
}
/**
* Gets this origin as a byte array, if possible.
*
* @param charset The charset to use if conversion from bytes is needed.
* @return this origin as a byte array, if possible.
* @throws IOException if an I/O error occurs.
* @throws UnsupportedOperationException if the origin cannot be converted to a Path.
*/
public CharSequence getCharSequence(final Charset charset) throws IOException {
return new String(getByteArray(), charset);
}
/**
* Gets this origin as a Path, if possible.
*
* @return this origin as a Path, if possible.
* @throws UnsupportedOperationException if this method is not implemented in a concrete subclass.
*/
public File getFile() {
throw new UnsupportedOperationException(
String.format("%s#getFile() for %s origin %s", getSimpleName(), origin.getClass().getSimpleName(), origin));
}
/**
* Gets this origin as an InputStream, if possible.
*
* @param options options specifying how the file is opened
* @return this origin as an InputStream, if possible.
* @throws IOException if an I/O error occurs.
* @throws UnsupportedOperationException if the origin cannot be converted to a Path.
*/
public InputStream getInputStream(final OpenOption... options) throws IOException {
return Files.newInputStream(getPath(), options);
}
/**
* Gets this origin as an OutputStream, if possible.
*
* @param options options specifying how the file is opened
* @return this origin as an OutputStream, if possible.
* @throws IOException if an I/O error occurs.
* @throws UnsupportedOperationException if the origin cannot be converted to a Path.
*/
public OutputStream getOutputStream(final OpenOption... options) throws IOException {
return Files.newOutputStream(getPath(), options);
}
/**
* Gets this origin as a Path, if possible.
*
* @return this origin as a Path, if possible.
* @throws UnsupportedOperationException if this method is not implemented in a concrete subclass.
*/
public Path getPath() {
throw new UnsupportedOperationException(
String.format("%s#getPath() for %s origin %s", getSimpleName(), origin.getClass().getSimpleName(), origin));
}
/**
* Gets a new Reader on the origin, buffered by default.
*
* @param charset the charset to use for decoding
* @return a new Reader on the origin.
* @throws IOException if an I/O error occurs opening the file.
*/
public Reader getReader(final Charset charset) throws IOException {
return Files.newBufferedReader(getPath(), charset);
}
private String getSimpleName() {
return getClass().getSimpleName();
}
/**
* Gets a new Writer on the origin, buffered by default.
*
* @param charset the charset to use for encoding
* @param options options specifying how the file is opened
* @return a new Writer on the origin.
* @throws IOException if an I/O error occurs opening or creating the file.
* @throws UnsupportedOperationException if the origin cannot be converted to a Path.
*/
public Writer getWriter(final Charset charset, final OpenOption... options) throws IOException {
return Files.newBufferedWriter(getPath(), charset, options);
}
/**
* Gets the size of the origin, if possible.
*
* @return the size of the origin in bytes or characters.
* @throws IOException if an I/O error occurs.
* @since 2.13.0
*/
public long size() throws IOException {
return Files.size(getPath());
}
@Override
public String toString() {
return getSimpleName() + "[" + origin.toString() + "]";
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/build/AbstractOriginSupplier.java 0100644 0000000 0000000 00000020210 14603604450 032131 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.build;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.net.URI;
import java.nio.file.Path;
import java.nio.file.Paths;
import org.apache.commons.io.build.AbstractOrigin.ByteArrayOrigin;
import org.apache.commons.io.build.AbstractOrigin.CharSequenceOrigin;
import org.apache.commons.io.build.AbstractOrigin.FileOrigin;
import org.apache.commons.io.build.AbstractOrigin.InputStreamOrigin;
import org.apache.commons.io.build.AbstractOrigin.OutputStreamOrigin;
import org.apache.commons.io.build.AbstractOrigin.PathOrigin;
import org.apache.commons.io.build.AbstractOrigin.ReaderOrigin;
import org.apache.commons.io.build.AbstractOrigin.URIOrigin;
import org.apache.commons.io.build.AbstractOrigin.WriterOrigin;
/**
* Abstracts building an instance of {@code T}.
*
* @param the type of instances to build.
* @param the type of builder subclass.
* @since 2.12.0
*/
public abstract class AbstractOriginSupplier> extends AbstractSupplier {
/**
* Constructs a new byte array origin for a byte array.
*
* @param origin the byte array.
* @return a new byte array origin.
*/
protected static ByteArrayOrigin newByteArrayOrigin(final byte[] origin) {
return new ByteArrayOrigin(origin);
}
/**
* Constructs a new CharSequence origin for a CharSequence.
*
* @param origin the CharSequence.
* @return a new file origin.
* @since 2.13.0
*/
protected static CharSequenceOrigin newCharSequenceOrigin(final CharSequence origin) {
return new CharSequenceOrigin(origin);
}
/**
* Constructs a new file origin for a file.
*
* @param origin the file.
* @return a new file origin.
*/
protected static FileOrigin newFileOrigin(final File origin) {
return new FileOrigin(origin);
}
/**
* Constructs a new file origin for a file path.
*
* @param origin the file path.
* @return a new file origin.
*/
protected static FileOrigin newFileOrigin(final String origin) {
return new FileOrigin(new File(origin));
}
/**
* Constructs a new input stream origin for a file.
*
* @param origin the input stream.
* @return a new input stream origin.
*/
protected static InputStreamOrigin newInputStreamOrigin(final InputStream origin) {
return new InputStreamOrigin(origin);
}
/**
* Constructs a new output stream origin for a file.
*
* @param origin the output stream.
* @return a new output stream origin.
*/
protected static OutputStreamOrigin newOutputStreamOrigin(final OutputStream origin) {
return new OutputStreamOrigin(origin);
}
/**
* Constructs a new path origin for a file.
*
* @param origin the path.
* @return a new path origin.
*/
protected static PathOrigin newPathOrigin(final Path origin) {
return new PathOrigin(origin);
}
/**
* Constructs a new path name origin for a path name.
*
* @param origin the path name.
* @return a new path name origin.
*/
protected static PathOrigin newPathOrigin(final String origin) {
return new PathOrigin(Paths.get(origin));
}
/**
* Constructs a new reader origin for a reader.
*
* @param origin the reader.
* @return a new reader origin.
*/
protected static ReaderOrigin newReaderOrigin(final Reader origin) {
return new ReaderOrigin(origin);
}
/**
* Constructs a new reader origin for a URI.
*
* @param origin the URI.
* @return a new URI origin.
*/
protected static URIOrigin newURIOrigin(final URI origin) {
return new URIOrigin(origin);
}
/**
* Constructs a new writer origin for a file.
*
* @param origin the writer.
* @return a new writer .
*/
protected static WriterOrigin newWriterOrigin(final Writer origin) {
return new WriterOrigin(origin);
}
/**
* The underlying origin.
*/
private AbstractOrigin origin;
/**
* Checks whether the origin is null.
*
* @return the origin.
* @throws IllegalStateException if the {@code origin} is {@code null}.
*/
protected AbstractOrigin checkOrigin() {
if (origin == null) {
throw new IllegalStateException("origin == null");
}
return origin;
}
/**
* Gets the origin.
*
* @return the origin.
*/
protected AbstractOrigin getOrigin() {
return origin;
}
/**
* Tests whether the origin is null.
*
* @return whether the origin is null.
*/
protected boolean hasOrigin() {
return origin != null;
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
public B setByteArray(final byte[] origin) {
return setOrigin(newByteArrayOrigin(origin));
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
* @since 2.13.0
*/
public B setCharSequence(final CharSequence origin) {
return setOrigin(newCharSequenceOrigin(origin));
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
public B setFile(final File origin) {
return setOrigin(newFileOrigin(origin));
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
public B setFile(final String origin) {
return setOrigin(newFileOrigin(origin));
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
public B setInputStream(final InputStream origin) {
return setOrigin(newInputStreamOrigin(origin));
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
protected B setOrigin(final AbstractOrigin origin) {
this.origin = origin;
return asThis();
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
public B setOutputStream(final OutputStream origin) {
return setOrigin(newOutputStreamOrigin(origin));
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
public B setPath(final Path origin) {
return setOrigin(newPathOrigin(origin));
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
public B setPath(final String origin) {
return setOrigin(newPathOrigin(origin));
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
public B setReader(final Reader origin) {
return setOrigin(newReaderOrigin(origin));
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
public B setURI(final URI origin) {
return setOrigin(newURIOrigin(origin));
}
/**
* Sets a new origin.
*
* @param origin the new origin.
* @return this
*/
public B setWriter(final Writer origin) {
return setOrigin(newWriterOrigin(origin));
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/build/AbstractStreamBuilder.java 0100644 0000000 0000000 00000027456 14603604450 031743 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.build;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.nio.charset.Charset;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.util.function.IntUnaryOperator;
import org.apache.commons.io.Charsets;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.file.PathUtils;
/**
* Abstracts building a typed instance of {@code T}.
*
* @param the type of instances to build.
* @param the type of builder subclass.
* @since 2.12.0
*/
public abstract class AbstractStreamBuilder> extends AbstractOriginSupplier {
private static final int DEFAULT_MAX_VALUE = Integer.MAX_VALUE;
private static final OpenOption[] DEFAULT_OPEN_OPTIONS = PathUtils.EMPTY_OPEN_OPTION_ARRAY;
/**
* The buffer size, defaults to {@link IOUtils#DEFAULT_BUFFER_SIZE} ({@value IOUtils#DEFAULT_BUFFER_SIZE}).
*/
private int bufferSize = IOUtils.DEFAULT_BUFFER_SIZE;
/**
* The buffer size, defaults to {@link IOUtils#DEFAULT_BUFFER_SIZE} ({@value IOUtils#DEFAULT_BUFFER_SIZE}).
*/
private int bufferSizeDefault = IOUtils.DEFAULT_BUFFER_SIZE;
/**
* The maximum buffer size.
*/
private int bufferSizeMax = DEFAULT_MAX_VALUE;
/**
* The Charset, defaults to {@link Charset#defaultCharset()}.
*/
private Charset charset = Charset.defaultCharset();
/**
* The Charset, defaults to {@link Charset#defaultCharset()}.
*/
private Charset charsetDefault = Charset.defaultCharset();
private OpenOption[] openOptions = DEFAULT_OPEN_OPTIONS;
/**
* The default checking behavior for a buffer size request. Throws a {@link IllegalArgumentException} by default.
*/
private final IntUnaryOperator defaultSizeChecker = size -> size > bufferSizeMax ? throwIae(size, bufferSizeMax) : size;
/**
* The checking behavior for a buffer size request.
*/
private IntUnaryOperator bufferSizeChecker = defaultSizeChecker;
/**
* Applies the buffer size request.
*
* @param size the size request.
* @return the size to use, usually the input, or can throw an unchecked exception, like {@link IllegalArgumentException}.
*/
private int checkBufferSize(final int size) {
return bufferSizeChecker.applyAsInt(size);
}
/**
* Gets the buffer size, defaults to {@link IOUtils#DEFAULT_BUFFER_SIZE} ({@value IOUtils#DEFAULT_BUFFER_SIZE}).
*
* @return the buffer size, defaults to {@link IOUtils#DEFAULT_BUFFER_SIZE} ({@value IOUtils#DEFAULT_BUFFER_SIZE}).
*/
protected int getBufferSize() {
return bufferSize;
}
/**
* Gets the buffer size default, defaults to {@link IOUtils#DEFAULT_BUFFER_SIZE} ({@value IOUtils#DEFAULT_BUFFER_SIZE}).
*
* @return the buffer size default, defaults to {@link IOUtils#DEFAULT_BUFFER_SIZE} ({@value IOUtils#DEFAULT_BUFFER_SIZE}).
*/
protected int getBufferSizeDefault() {
return bufferSizeDefault;
}
/**
* Gets a CharSequence from the origin with a Charset.
*
* @return An input stream
* @throws IllegalStateException if the {@code origin} is {@code null}.
* @throws UnsupportedOperationException if the origin cannot be converted to a CharSequence.
* @throws IOException if an I/O error occurs.
* @see AbstractOrigin#getCharSequence(Charset)
* @since 2.13.0
*/
protected CharSequence getCharSequence() throws IOException {
return checkOrigin().getCharSequence(getCharset());
}
/**
* Gets the Charset, defaults to {@link Charset#defaultCharset()}.
*
* @return the Charset, defaults to {@link Charset#defaultCharset()}.
*/
public Charset getCharset() {
return charset;
}
/**
* Gets the Charset default, defaults to {@link Charset#defaultCharset()}.
*
* @return the Charset default, defaults to {@link Charset#defaultCharset()}.
*/
protected Charset getCharsetDefault() {
return charsetDefault;
}
/**
* Gets an InputStream from the origin with OpenOption[].
*
* @return An input stream
* @throws IllegalStateException if the {@code origin} is {@code null}.
* @throws UnsupportedOperationException if the origin cannot be converted to an {@link InputStream}.
* @throws IOException if an I/O error occurs.
* @see AbstractOrigin#getInputStream(OpenOption...)
* @see #getOpenOptions()
* @since 2.13.0
*/
protected InputStream getInputStream() throws IOException {
return checkOrigin().getInputStream(getOpenOptions());
}
/**
* Gets the OpenOption array.
*
* @return the OpenOption array.
*/
protected OpenOption[] getOpenOptions() {
return openOptions;
}
/**
* Gets an OutputStream from the origin with OpenOption[].
*
* @return An OutputStream
* @throws IllegalStateException if the {@code origin} is {@code null}.
* @throws UnsupportedOperationException if the origin cannot be converted to an {@link OutputStream}.
* @throws IOException if an I/O error occurs.
* @see AbstractOrigin#getOutputStream(OpenOption...)
* @see #getOpenOptions()
* @since 2.13.0
*/
protected OutputStream getOutputStream() throws IOException {
return checkOrigin().getOutputStream(getOpenOptions());
}
/**
* Gets a Path from the origin.
*
* @return A Path
* @throws IllegalStateException if the {@code origin} is {@code null}.
* @throws UnsupportedOperationException if the origin cannot be converted to a {@link Path}.
* @see AbstractOrigin#getPath()
* @since 2.13.0
*/
protected Path getPath() {
return checkOrigin().getPath();
}
/**
* Gets a Reader from the origin with a Charset.
*
* @return A Reader
* @throws IllegalStateException if the {@code origin} is {@code null}.
* @throws UnsupportedOperationException if the origin cannot be converted to a {@link Reader}.
* @throws IOException if an I/O error occurs.
* @see AbstractOrigin#getReader(Charset)
* @see #getCharset()
* @since 2.16.0
*/
protected Reader getReader() throws IOException {
return checkOrigin().getReader(getCharset());
}
/**
* Gets a Writer from the origin with an OpenOption[].
*
* @return An writer.
* @throws IllegalStateException if the {@code origin} is {@code null}.
* @throws UnsupportedOperationException if the origin cannot be converted to a {@link Writer}.
* @throws IOException if an I/O error occurs.
* @see AbstractOrigin#getOutputStream(OpenOption...)
* @see #getOpenOptions()
* @since 2.13.0
*/
protected Writer getWriter() throws IOException {
return checkOrigin().getWriter(getCharset(), getOpenOptions());
}
/**
* Sets the buffer size. Invalid input (bufferSize <= 0) resets the value to its default.
*
* Subclasses may ignore this setting.
*
*
* @param bufferSize the buffer size.
* @return this.
*/
public B setBufferSize(final int bufferSize) {
this.bufferSize = checkBufferSize(bufferSize > 0 ? bufferSize : bufferSizeDefault);
return asThis();
}
/**
* Sets the buffer size.
*
* Subclasses may ignore this setting.
*
*
* @param bufferSize the buffer size, null resets to the default.
* @return this.
*/
public B setBufferSize(final Integer bufferSize) {
setBufferSize(bufferSize != null ? bufferSize : bufferSizeDefault);
return asThis();
}
/**
* Sets the buffer size checker function. Throws a {@link IllegalArgumentException} by default.
*
* @param bufferSizeChecker the buffer size checker function. null resets to the default behavior.
* @return this
* @since 2.14.0
*/
public B setBufferSizeChecker(final IntUnaryOperator bufferSizeChecker) {
this.bufferSizeChecker = bufferSizeChecker != null ? bufferSizeChecker : defaultSizeChecker;
return asThis();
}
/**
* Sets the buffer size for subclasses to initialize.
*
* Subclasses may ignore this setting.
*
*
* @param bufferSizeDefault the buffer size, null resets to the default.
* @return this.
*/
protected B setBufferSizeDefault(final int bufferSizeDefault) {
this.bufferSizeDefault = bufferSizeDefault;
return asThis();
}
/**
* The maximum buffer size checked by the buffer size checker. Values less or equal to 0, resets to the int max value. By default, if this value is
* exceeded, this methods throws an {@link IllegalArgumentException}.
*
* @param bufferSizeMax maximum buffer size checked by the buffer size checker.
* @return this.
* @since 2.14.0
*/
public B setBufferSizeMax(final int bufferSizeMax) {
this.bufferSizeMax = bufferSizeMax > 0 ? bufferSizeMax : DEFAULT_MAX_VALUE;
return asThis();
}
/**
* Sets the Charset.
*
* Subclasses may ignore this setting.
*
*
* @param charset the Charset, null resets to the default.
* @return this.
*/
public B setCharset(final Charset charset) {
this.charset = Charsets.toCharset(charset, charsetDefault);
return asThis();
}
/**
* Sets the Charset.
*
* Subclasses may ignore this setting.
*
*
* @param charset the Charset name, null resets to the default.
* @return this.
*/
public B setCharset(final String charset) {
return setCharset(Charsets.toCharset(charset, charsetDefault));
}
/**
* Sets the Charset default for subclasses to initialize.
*
* Subclasses may ignore this setting.
*
*
* @param defaultCharset the Charset name, null resets to the default.
* @return this.
*/
protected B setCharsetDefault(final Charset defaultCharset) {
this.charsetDefault = defaultCharset;
return asThis();
}
/**
* Sets the OpenOption[].
*
* Normally used with InputStream, OutputStream, and Writer.
*
*
* Subclasses may ignore this setting.
*
*
* @param openOptions the OpenOption[] name, null resets to the default.
* @return this.
* @since 2.13.0
* @see #setInputStream(InputStream)
* @see #setOutputStream(OutputStream)
* @see #setWriter(Writer)
*/
public B setOpenOptions(final OpenOption... openOptions) {
this.openOptions = openOptions != null ? openOptions : DEFAULT_OPEN_OPTIONS;
return asThis();
}
private int throwIae(final int size, final int max) {
throw new IllegalArgumentException(String.format("Request %,d exceeds maximum %,d", size, max));
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/build/AbstractSupplier.java 0100644 0000000 0000000 00000002651 14603604450 030772 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.build;
import org.apache.commons.io.function.IOSupplier;
/**
* Abstracts supplying an instance of {@code T}. Use to implement the builder pattern.
*
* @param the type of instances to build.
* @param the type of builder subclass.
* @since 2.12.0
*/
public abstract class AbstractSupplier> implements IOSupplier {
/**
* Returns this instance typed as the proper subclass type.
*
* @return this instance typed as the proper subclass type.
*/
@SuppressWarnings("unchecked")
protected B asThis() {
return (B) this;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/build/package-info.java 0100644 0000000 0000000 00000001623 14603604450 030025 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/**
* Provides classes to implement IO builders.
*
* @since 2.12.0
*/
package org.apache.commons.io.build;
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/channels/FileChannels.java 0100644 0000000 0000000 00000005632 14603604450 030534 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.channels;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Objects;
import org.apache.commons.io.IOUtils;
/**
* Works with {@link FileChannel}.
*
* @since 2.15.0
*/
public final class FileChannels {
/**
* Tests if two RandomAccessFiles contents are equal.
*
* @param channel1 A FileChannel.
* @param channel2 Another FileChannel.
* @param byteBufferSize The two internal buffer capacities, in bytes.
* @return true if the contents of both RandomAccessFiles are equal, false otherwise.
* @throws IOException if an I/O error occurs.
*/
public static boolean contentEquals(final FileChannel channel1, final FileChannel channel2, final int byteBufferSize) throws IOException {
// Short-circuit test
if (Objects.equals(channel1, channel2)) {
return true;
}
// Short-circuit test
final long size1 = size(channel1);
final long size2 = size(channel2);
if (size1 != size2) {
return false;
}
if (size1 == 0 && size2 == 0) {
return true;
}
// Dig in and do the work
final ByteBuffer byteBuffer1 = ByteBuffer.allocateDirect(byteBufferSize);
final ByteBuffer byteBuffer2 = ByteBuffer.allocateDirect(byteBufferSize);
while (true) {
final int read1 = channel1.read(byteBuffer1);
final int read2 = channel2.read(byteBuffer2);
byteBuffer1.clear();
byteBuffer2.clear();
if (read1 == IOUtils.EOF && read2 == IOUtils.EOF) {
return byteBuffer1.equals(byteBuffer2);
}
if (read1 != read2) {
return false;
}
if (!byteBuffer1.equals(byteBuffer2)) {
return false;
}
}
}
private static long size(final FileChannel channel) throws IOException {
return channel != null ? channel.size() : 0;
}
/**
* Don't instantiate.
*/
private FileChannels() {
// no-op
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/channels/package-info.java 0100644 0000000 0000000 00000001644 14603604450 030524 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/**
* Provides classes to work with {@link java.nio.channels}.
*
* @since 2.15.0
*/
package org.apache.commons.io.channels;
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/charset/CharsetDecoders.java 0100644 0000000 0000000 00000003014 14603604450 031071 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.charset;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
/**
* Works with {@link CharsetDecoder}.
*
* @since 2.12.0
*/
public final class CharsetDecoders {
/**
* Returns the given non-null CharsetDecoder or a new default CharsetDecoder.
*
* @param charsetDecoder The CharsetDecoder to test.
* @return the given non-null CharsetDecoder or a new default CharsetDecoder.
*/
public static CharsetDecoder toCharsetDecoder(final CharsetDecoder charsetDecoder) {
return charsetDecoder != null ? charsetDecoder : Charset.defaultCharset().newDecoder();
}
/** No instances. */
private CharsetDecoders() {
// No instances.
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/charset/CharsetEncoders.java 0100644 0000000 0000000 00000004166 14603604450 031114 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.charset;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.util.function.Supplier;
/**
* Works with {@link CharsetEncoder}.
*
* @since 2.12.0
*/
public final class CharsetEncoders {
/**
* Returns the given non-null CharsetEncoder or a new default CharsetEncoder.
*
* @param charsetEncoder The CharsetEncoder to test.
* @return the given non-null CharsetEncoder or a new default CharsetEncoder.
*/
public static CharsetEncoder toCharsetEncoder(final CharsetEncoder charsetEncoder) {
return toCharsetEncoder(charsetEncoder, () -> Charset.defaultCharset().newEncoder());
}
/**
* Returns the given non-null CharsetEncoder or a new default CharsetEncoder.
*
* @param charsetEncoder The CharsetEncoder to test.
* @param defaultSupplier The CharsetEncoder supplier to get when charsetEncoder is null.
* @return the given non-null CharsetEncoder or a new default CharsetEncoder.
* @since 2.13.0
*/
public static CharsetEncoder toCharsetEncoder(final CharsetEncoder charsetEncoder, final Supplier defaultSupplier) {
return charsetEncoder != null ? charsetEncoder : defaultSupplier.get();
}
/** No instances. */
private CharsetEncoders() {
// No instances.
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/charset/package-info.java 0100644 0000000 0000000 00000001654 14603604450 030363 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/**
* Provides classes to work with code from {@link java.nio.charset}.
*
* @since 2.12.0
*/
package org.apache.commons.io.charset;
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/AbstractFileComparator.java 0100644 0000000 0000000 00000004235 14603604450 033146 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.comparator;
import java.io.File;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
/**
* Abstract file {@link Comparator} which provides sorting for file arrays and lists.
*
* @since 2.0
*/
abstract class AbstractFileComparator implements Comparator {
/**
* Sorts an array of files.
*
* This method uses {@link Arrays#sort(Object[], Comparator)} and returns the original array.
*
*
* @param files The files to sort, may be null.
* @return The sorted array.
* @since 2.0
*/
public File[] sort(final File... files) {
if (files != null) {
Arrays.sort(files, this);
}
return files;
}
/**
* Sorts a List of files.
*
* This method uses {@link List#sort(Comparator)} and returns the original list.
*
*
* @param files The files to sort, may be null.
* @return The sorted list.
* @since 2.0
*/
public List sort(final List files) {
if (files != null) {
files.sort(this);
}
return files;
}
/**
* String representation of this file comparator.
*
* @return String representation of this file comparator.
*/
@Override
public String toString() {
return getClass().getSimpleName();
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/CompositeFileComparator.java 0100644 0000000 0000000 00000007726 14603604450 033355 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.comparator;
import java.io.File;
import java.io.Serializable;
import java.util.Comparator;
import java.util.function.IntFunction;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
/**
* Compare two files using a set of delegate file {@link Comparator}.
*
* This comparator can be used to sort lists or arrays of files by combining a number of other comparators.
*
* Example of sorting a list of files by type (i.e. directory or file) and then by name:
*
*
* CompositeFileComparator comparator = new CompositeFileComparator(
* DirectoryFileComparator.DIRECTORY_COMPARATOR,
* NameFileComparator.NAME_COMPARATOR);
* List<File> list = ...
* comparator.sort(list);
*
* Deprecating Serialization
*
* Serialization is deprecated and will be removed in 3.0.
*
*
* @since 2.0
*/
public class CompositeFileComparator extends AbstractFileComparator implements Serializable {
private static final Comparator[] EMPTY_COMPARATOR_ARRAY = {};
private static final long serialVersionUID = -2224170307287243428L;
/**
* Delegates.
*/
private final Comparator[] delegates;
/**
* Constructs a composite comparator for the set of delegate comparators.
*
* @param delegates The delegate file comparators
*/
public CompositeFileComparator(@SuppressWarnings("unchecked") final Comparator... delegates) {
this.delegates = delegates == null ? emptyArray() : delegates.clone();
}
/**
* Constructs a composite comparator for the set of delegate comparators.
*
* @param delegates The delegate file comparators
*/
public CompositeFileComparator(final Iterable> delegates) {
this.delegates = delegates == null ? emptyArray()
: StreamSupport.stream(delegates.spliterator(), false).toArray((IntFunction[]>) Comparator[]::new);
}
/**
* Compares the two files using delegate comparators.
*
* @param file1 The first file to compare
* @param file2 The second file to compare
* @return the first non-zero result returned from the delegate comparators or zero.
*/
@Override
public int compare(final File file1, final File file2) {
return Stream.of(delegates).map(delegate -> delegate.compare(file1, file2)).filter(r -> r != 0).findFirst().orElse(0);
}
@SuppressWarnings("unchecked") // types are already correct
private Comparator[] emptyArray() {
return (Comparator[]) EMPTY_COMPARATOR_ARRAY;
}
/**
* String representation of this file comparator.
*
* @return String representation of this file comparator
*/
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
builder.append(super.toString());
builder.append('{');
for (int i = 0; i < delegates.length; i++) {
if (i > 0) {
builder.append(',');
}
builder.append(delegates[i]);
}
builder.append('}');
return builder.toString();
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/DefaultFileComparator.java 0100644 0000000 0000000 00000005373 14603604450 032773 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.comparator;
import java.io.File;
import java.io.Serializable;
import java.util.Comparator;
/**
* Compares two files using the default {@link File#compareTo(File)} method.
*
* This comparator can be used to sort lists or arrays of files
* by using the default file comparison.
*
*
* Example of sorting a list of files using the
* {@link #DEFAULT_COMPARATOR} singleton instance:
*
*
* List<File> list = ...
* ((AbstractFileComparator) DefaultFileComparator.DEFAULT_COMPARATOR).sort(list);
*
*
* Example of doing a reverse sort of an array of files using the
* {@link #DEFAULT_REVERSE} singleton instance:
*
*
* File[] array = ...
* ((AbstractFileComparator) DefaultFileComparator.DEFAULT_REVERSE).sort(array);
*
* Deprecating Serialization
*
* Serialization is deprecated and will be removed in 3.0.
*
*
* @since 1.4
*/
public class DefaultFileComparator extends AbstractFileComparator implements Serializable {
private static final long serialVersionUID = 3260141861365313518L;
/** Singleton default comparator instance */
public static final Comparator DEFAULT_COMPARATOR = new DefaultFileComparator();
/** Singleton reverse default comparator instance */
public static final Comparator DEFAULT_REVERSE = new ReverseFileComparator(DEFAULT_COMPARATOR);
/**
* Constructs a new instance.
*/
public DefaultFileComparator() {
// empty
}
/**
* Compares the two files using the {@link File#compareTo(File)} method.
*
* @param file1 The first file to compare
* @param file2 The second file to compare
* @return the result of calling file1's
* {@link File#compareTo(File)} with file2 as the parameter.
*/
@Override
public int compare(final File file1, final File file2) {
return file1.compareTo(file2);
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/DirectoryFileComparator.java 0100644 0000000 0000000 00000005762 14603604450 033355 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.comparator;
import java.io.File;
import java.io.Serializable;
import java.util.Comparator;
/**
* Compare two files using the {@link File#isDirectory()} method.
*
* This comparator can be used to sort lists or arrays by directories and files.
*
*
* Example of sorting a list of files/directories using the {@link #DIRECTORY_COMPARATOR} singleton instance:
*
*
*
* List<File> list = ...
* ((AbstractFileComparator) DirectoryFileComparator.DIRECTORY_COMPARATOR).sort(list);
*
*
* Example of doing a reverse sort of an array of files/directories using the {@link #DIRECTORY_REVERSE}
* singleton instance:
*
*
*
* File[] array = ...
* ((AbstractFileComparator) DirectoryFileComparator.DIRECTORY_REVERSE).sort(array);
*
* Deprecating Serialization
*
* Serialization is deprecated and will be removed in 3.0.
*
*
* @since 2.0
*/
public class DirectoryFileComparator extends AbstractFileComparator implements Serializable {
private static final int TYPE_FILE = 2;
private static final int TYPE_DIRECTORY = 1;
private static final long serialVersionUID = 296132640160964395L;
/** Singleton default comparator instance */
public static final Comparator DIRECTORY_COMPARATOR = new DirectoryFileComparator();
/** Singleton reverse default comparator instance */
public static final Comparator DIRECTORY_REVERSE = new ReverseFileComparator(DIRECTORY_COMPARATOR);
/**
* Compares the two files using the {@link File#isDirectory()} method.
*
* @param file1 The first file to compare.
* @param file2 The second file to compare.
* @return the result of calling file1's {@link File#compareTo(File)} with file2 as the parameter.
*/
@Override
public int compare(final File file1, final File file2) {
return getType(file1) - getType(file2);
}
/**
* Converts type to numeric value.
*
* @param file The file.
* @return 1 for directories and 2 for files.
*/
private int getType(final File file) {
return file.isDirectory() ? TYPE_DIRECTORY : TYPE_FILE;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/ExtensionFileComparator.java 0100644 0000000 0000000 00000012206 14603604450 033354 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.comparator;
import java.io.File;
import java.io.Serializable;
import java.util.Comparator;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOCase;
/**
* Compare the file name extensions for order
* (see {@link FilenameUtils#getExtension(String)}).
*
* This comparator can be used to sort lists or arrays of files
* by their file extension either in a case-sensitive, case-insensitive or
* system dependent case-sensitive way. A number of singleton instances
* are provided for the various case sensitivity options (using {@link IOCase})
* and the reverse of those options.
*
*
* Example of a case-sensitive file extension sort using the
* {@link #EXTENSION_COMPARATOR} singleton instance:
*
*
* List<File> list = ...
* ((AbstractFileComparator) ExtensionFileComparator.EXTENSION_COMPARATOR).sort(list);
*
*
* Example of a reverse case-insensitive file extension sort using the
* {@link #EXTENSION_INSENSITIVE_REVERSE} singleton instance:
*
*
* File[] array = ...
* ((AbstractFileComparator) ExtensionFileComparator.EXTENSION_INSENSITIVE_REVERSE).sort(array);
*
* Deprecating Serialization
*
* Serialization is deprecated and will be removed in 3.0.
*
*
* @since 1.4
*/
public class ExtensionFileComparator extends AbstractFileComparator implements Serializable {
private static final long serialVersionUID = 1928235200184222815L;
/** Case-sensitive extension comparator instance (see {@link IOCase#SENSITIVE}) */
public static final Comparator EXTENSION_COMPARATOR = new ExtensionFileComparator();
/** Reverse case-sensitive extension comparator instance (see {@link IOCase#SENSITIVE}) */
public static final Comparator EXTENSION_REVERSE = new ReverseFileComparator(EXTENSION_COMPARATOR);
/** Case-insensitive extension comparator instance (see {@link IOCase#INSENSITIVE}) */
public static final Comparator EXTENSION_INSENSITIVE_COMPARATOR
= new ExtensionFileComparator(IOCase.INSENSITIVE);
/** Reverse case-insensitive extension comparator instance (see {@link IOCase#INSENSITIVE}) */
public static final Comparator EXTENSION_INSENSITIVE_REVERSE
= new ReverseFileComparator(EXTENSION_INSENSITIVE_COMPARATOR);
/** System sensitive extension comparator instance (see {@link IOCase#SYSTEM}) */
public static final Comparator EXTENSION_SYSTEM_COMPARATOR = new ExtensionFileComparator(IOCase.SYSTEM);
/** Reverse system sensitive path comparator instance (see {@link IOCase#SYSTEM}) */
public static final Comparator EXTENSION_SYSTEM_REVERSE = new ReverseFileComparator(EXTENSION_SYSTEM_COMPARATOR);
/** Whether the comparison is case-sensitive. */
private final IOCase ioCase;
/**
* Constructs a case-sensitive file extension comparator instance.
*/
public ExtensionFileComparator() {
this.ioCase = IOCase.SENSITIVE;
}
/**
* Constructs a file extension comparator instance with the specified case-sensitivity.
*
* @param ioCase how to handle case sensitivity, null means case-sensitive
*/
public ExtensionFileComparator(final IOCase ioCase) {
this.ioCase = IOCase.value(ioCase, IOCase.SENSITIVE);
}
/**
* Compares the extensions of two files the specified case sensitivity.
*
* @param file1 The first file to compare
* @param file2 The second file to compare
* @return a negative value if the first file's extension
* is less than the second, zero if the extensions are the
* same and a positive value if the first files extension
* is greater than the second file.
*/
@Override
public int compare(final File file1, final File file2) {
final String suffix1 = FilenameUtils.getExtension(file1.getName());
final String suffix2 = FilenameUtils.getExtension(file2.getName());
return ioCase.checkCompareTo(suffix1, suffix2);
}
/**
* String representation of this file comparator.
*
* @return String representation of this file comparator
*/
@Override
public String toString() {
return super.toString() + "[ioCase=" + ioCase + "]";
}
}
././@LongLink 0100644 0000000 0000000 00000000145 14603604450 011635 L ustar 0000000 0000000 commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/LastModifiedFileComparator.java commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/LastModifiedFileComparator.java0100644 0000000 0000000 00000006156 14603604450 033753 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.comparator;
import java.io.File;
import java.io.Serializable;
import java.util.Comparator;
import org.apache.commons.io.FileUtils;
/**
* Compare the last modified date/time of two files for order
* (see {@link FileUtils#lastModifiedUnchecked(File)}).
*
* This comparator can be used to sort lists or arrays of files
* by their last modified date/time.
*
*
* Example of sorting a list of files using the
* {@link #LASTMODIFIED_COMPARATOR} singleton instance:
*
*
* List<File> list = ...
* ((AbstractFileComparator) LastModifiedFileComparator.LASTMODIFIED_COMPARATOR).sort(list);
*
*
* Example of doing a reverse sort of an array of files using the
* {@link #LASTMODIFIED_REVERSE} singleton instance:
*
*
* File[] array = ...
* ((AbstractFileComparator) LastModifiedFileComparator.LASTMODIFIED_REVERSE).sort(array);
*
* Deprecating Serialization
*
* Serialization is deprecated and will be removed in 3.0.
*
*
* @since 1.4
*/
public class LastModifiedFileComparator extends AbstractFileComparator implements Serializable {
private static final long serialVersionUID = 7372168004395734046L;
/** Last modified comparator instance. */
public static final Comparator LASTMODIFIED_COMPARATOR = new LastModifiedFileComparator();
/** Reverse last modified comparator instance. */
public static final Comparator LASTMODIFIED_REVERSE = new ReverseFileComparator(LASTMODIFIED_COMPARATOR);
/**
* Compares the last modified date/time of two files.
*
* @param file1 The first file to compare.
* @param file2 The second file to compare.
* @return a negative value if the first file's last modified date/time is less than the second, zero if the last
* modified date/time are the same and a positive value if the first files last modified date/time is
* greater than the second file.
*/
@Override
public int compare(final File file1, final File file2) {
final long result = FileUtils.lastModifiedUnchecked(file1) - FileUtils.lastModifiedUnchecked(file2);
if (result < 0) {
return -1;
}
if (result > 0) {
return 1;
}
return 0;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/NameFileComparator.java 0100644 0000000 0000000 00000011253 14603604450 032261 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.comparator;
import java.io.File;
import java.io.Serializable;
import java.util.Comparator;
import org.apache.commons.io.IOCase;
/**
* Compare the names of two files for order (see {@link File#getName()}).
*
* This comparator can be used to sort lists or arrays of files
* by their name either in a case-sensitive, case-insensitive or
* system dependent case-sensitive way. A number of singleton instances
* are provided for the various case sensitivity options (using {@link IOCase})
* and the reverse of those options.
*
*
* Example of a case-sensitive file name sort using the
* {@link #NAME_COMPARATOR} singleton instance:
*
*
* List<File> list = ...
* ((AbstractFileComparator) NameFileComparator.NAME_COMPARATOR).sort(list);
*
*
* Example of a reverse case-insensitive file name sort using the
* {@link #NAME_INSENSITIVE_REVERSE} singleton instance:
*
*
* File[] array = ...
* ((AbstractFileComparator) NameFileComparator.NAME_INSENSITIVE_REVERSE).sort(array);
*
* Deprecating Serialization
*
* Serialization is deprecated and will be removed in 3.0.
*
*
* @since 1.4
*/
public class NameFileComparator extends AbstractFileComparator implements Serializable {
private static final long serialVersionUID = 8397947749814525798L;
/** Case-sensitive name comparator instance (see {@link IOCase#SENSITIVE}) */
public static final Comparator NAME_COMPARATOR = new NameFileComparator();
/** Reverse case-sensitive name comparator instance (see {@link IOCase#SENSITIVE}) */
public static final Comparator NAME_REVERSE = new ReverseFileComparator(NAME_COMPARATOR);
/** Case-insensitive name comparator instance (see {@link IOCase#INSENSITIVE}) */
public static final Comparator NAME_INSENSITIVE_COMPARATOR = new NameFileComparator(IOCase.INSENSITIVE);
/** Reverse case-insensitive name comparator instance (see {@link IOCase#INSENSITIVE}) */
public static final Comparator NAME_INSENSITIVE_REVERSE = new ReverseFileComparator(NAME_INSENSITIVE_COMPARATOR);
/** System sensitive name comparator instance (see {@link IOCase#SYSTEM}) */
public static final Comparator NAME_SYSTEM_COMPARATOR = new NameFileComparator(IOCase.SYSTEM);
/** Reverse system sensitive name comparator instance (see {@link IOCase#SYSTEM}) */
public static final Comparator NAME_SYSTEM_REVERSE = new ReverseFileComparator(NAME_SYSTEM_COMPARATOR);
/** Whether the comparison is case-sensitive. */
private final IOCase ioCase;
/**
* Constructs a case-sensitive file name comparator instance.
*/
public NameFileComparator() {
this.ioCase = IOCase.SENSITIVE;
}
/**
* Constructs a file name comparator instance with the specified case-sensitivity.
*
* @param ioCase how to handle case sensitivity, null means case-sensitive
*/
public NameFileComparator(final IOCase ioCase) {
this.ioCase = IOCase.value(ioCase, IOCase.SENSITIVE);
}
/**
* Compares the names of two files with the specified case sensitivity.
*
* @param file1 The first file to compare
* @param file2 The second file to compare
* @return a negative value if the first file's name
* is less than the second, zero if the names are the
* same and a positive value if the first files name
* is greater than the second file.
*/
@Override
public int compare(final File file1, final File file2) {
return ioCase.checkCompareTo(file1.getName(), file2.getName());
}
/**
* String representation of this file comparator.
*
* @return String representation of this file comparator
*/
@Override
public String toString() {
return super.toString() + "[ioCase=" + ioCase + "]";
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/PathFileComparator.java 0100644 0000000 0000000 00000011242 14603604450 032273 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.comparator;
import java.io.File;
import java.io.Serializable;
import java.util.Comparator;
import org.apache.commons.io.IOCase;
/**
* Compare the path of two files for order (see {@link File#getPath()}).
*
* This comparator can be used to sort lists or arrays of files
* by their path either in a case-sensitive, case-insensitive or
* system dependent case-sensitive way. A number of singleton instances
* are provided for the various case sensitivity options (using {@link IOCase})
* and the reverse of those options.
*
*
* Example of a case-sensitive file path sort using the
* {@link #PATH_COMPARATOR} singleton instance:
*
*
* List<File> list = ...
* ((AbstractFileComparator) PathFileComparator.PATH_COMPARATOR).sort(list);
*
*
* Example of a reverse case-insensitive file path sort using the
* {@link #PATH_INSENSITIVE_REVERSE} singleton instance:
*
*
* File[] array = ...
* ((AbstractFileComparator) PathFileComparator.PATH_INSENSITIVE_REVERSE).sort(array);
*
* Deprecating Serialization
*
* Serialization is deprecated and will be removed in 3.0.
*
* @since 1.4
*/
public class PathFileComparator extends AbstractFileComparator implements Serializable {
private static final long serialVersionUID = 6527501707585768673L;
/** Case-sensitive path comparator instance (see {@link IOCase#SENSITIVE}) */
public static final Comparator PATH_COMPARATOR = new PathFileComparator();
/** Reverse case-sensitive path comparator instance (see {@link IOCase#SENSITIVE}) */
public static final Comparator PATH_REVERSE = new ReverseFileComparator(PATH_COMPARATOR);
/** Case-insensitive path comparator instance (see {@link IOCase#INSENSITIVE}) */
public static final Comparator PATH_INSENSITIVE_COMPARATOR = new PathFileComparator(IOCase.INSENSITIVE);
/** Reverse case-insensitive path comparator instance (see {@link IOCase#INSENSITIVE}) */
public static final Comparator PATH_INSENSITIVE_REVERSE = new ReverseFileComparator(PATH_INSENSITIVE_COMPARATOR);
/** System sensitive path comparator instance (see {@link IOCase#SYSTEM}) */
public static final Comparator PATH_SYSTEM_COMPARATOR = new PathFileComparator(IOCase.SYSTEM);
/** Reverse system sensitive path comparator instance (see {@link IOCase#SYSTEM}) */
public static final Comparator PATH_SYSTEM_REVERSE = new ReverseFileComparator(PATH_SYSTEM_COMPARATOR);
/** Whether the comparison is case-sensitive. */
private final IOCase ioCase;
/**
* Constructs a case-sensitive file path comparator instance.
*/
public PathFileComparator() {
this.ioCase = IOCase.SENSITIVE;
}
/**
* Constructs a file path comparator instance with the specified case-sensitivity.
*
* @param ioCase how to handle case sensitivity, null means case-sensitive
*/
public PathFileComparator(final IOCase ioCase) {
this.ioCase = IOCase.value(ioCase, IOCase.SENSITIVE);
}
/**
* Compares the paths of two files the specified case sensitivity.
*
* @param file1 The first file to compare
* @param file2 The second file to compare
* @return a negative value if the first file's path
* is less than the second, zero if the paths are the
* same and a positive value if the first files path
* is greater than the second file.
*/
@Override
public int compare(final File file1, final File file2) {
return ioCase.checkCompareTo(file1.getPath(), file2.getPath());
}
/**
* String representation of this file comparator.
*
* @return String representation of this file comparator
*/
@Override
public String toString() {
return super.toString() + "[ioCase=" + ioCase + "]";
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/ReverseFileComparator.java 0100644 0000000 0000000 00000004700 14603604450 033013 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.comparator;
import java.io.File;
import java.io.Serializable;
import java.util.Comparator;
import java.util.Objects;
/**
* Reverses the result of comparing two {@link File} objects using the delegate {@link Comparator}.
* Deprecating Serialization
*
* Serialization is deprecated and will be removed in 3.0.
*
*
* @since 1.4
*/
final class ReverseFileComparator extends AbstractFileComparator implements Serializable {
private static final long serialVersionUID = -4808255005272229056L;
private final Comparator delegate;
/**
* Constructs an instance with the specified delegate {@link Comparator}.
*
* @param delegate The comparator to delegate to.
*/
public ReverseFileComparator(final Comparator delegate) {
this.delegate = Objects.requireNonNull(delegate, "delegate");
}
/**
* Compares using the delegate Comparator, reversing the result.
*
* @param file1 The first file to compare.
* @param file2 The second file to compare.
* @return the result from the delegate {@link Comparator#compare(Object, Object)} reversing the value (i.e.
* positive becomes negative and vice versa).
*/
@Override
public int compare(final File file1, final File file2) {
return delegate.compare(file2, file1); // parameters switched round
}
/**
* Returns the String representation of this file comparator.
*
* @return String representation of this file comparator.
*/
@Override
public String toString() {
return super.toString() + "[" + delegate.toString() + "]";
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/SizeFileComparator.java 0100644 0000000 0000000 00000012433 14603604450 032314 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.comparator;
import java.io.File;
import java.io.Serializable;
import java.util.Comparator;
import org.apache.commons.io.FileUtils;
/**
* Compare the length/size of two files for order (see
* {@link File#length()} and {@link FileUtils#sizeOfDirectory(File)}).
*
* This comparator can be used to sort lists or arrays of files
* by their length/size.
*
*
* Example of sorting a list of files using the
* {@link #SIZE_COMPARATOR} singleton instance:
*
*
* List<File> list = ...
* ((AbstractFileComparator) SizeFileComparator.SIZE_COMPARATOR).sort(list);
*
*
* Example of doing a reverse sort of an array of files using the
* {@link #SIZE_REVERSE} singleton instance:
*
*
* File[] array = ...
* ((AbstractFileComparator) SizeFileComparator.SIZE_REVERSE).sort(array);
*
*
* N.B. Directories are treated as zero size unless
* {@code sumDirectoryContents} is {@code true}.
*
* Deprecating Serialization
*
* Serialization is deprecated and will be removed in 3.0.
*
*
* @since 1.4
*/
public class SizeFileComparator extends AbstractFileComparator implements Serializable {
private static final long serialVersionUID = -1201561106411416190L;
/** Size comparator instance - directories are treated as zero size */
public static final Comparator SIZE_COMPARATOR = new SizeFileComparator();
/** Reverse size comparator instance - directories are treated as zero size */
public static final Comparator SIZE_REVERSE = new ReverseFileComparator(SIZE_COMPARATOR);
/**
* Size comparator instance which sums the size of a directory's contents
* using {@link FileUtils#sizeOfDirectory(File)}
*/
public static final Comparator SIZE_SUMDIR_COMPARATOR = new SizeFileComparator(true);
/**
* Reverse size comparator instance which sums the size of a directory's contents
* using {@link FileUtils#sizeOfDirectory(File)}
*/
public static final Comparator SIZE_SUMDIR_REVERSE = new ReverseFileComparator(SIZE_SUMDIR_COMPARATOR);
/** Whether the sum of the directory's contents should be calculated. */
private final boolean sumDirectoryContents;
/**
* Constructs a file size comparator instance (directories treated as zero size).
*/
public SizeFileComparator() {
this.sumDirectoryContents = false;
}
/**
* Constructs a file size comparator instance specifying whether the size of
* the directory contents should be aggregated.
*
* If the {@code sumDirectoryContents} is {@code true} The size of
* directories is calculated using {@link FileUtils#sizeOfDirectory(File)}.
*
*
* @param sumDirectoryContents {@code true} if the sum of the directories' contents
* should be calculated, otherwise {@code false} if directories should be treated
* as size zero (see {@link FileUtils#sizeOfDirectory(File)}).
*/
public SizeFileComparator(final boolean sumDirectoryContents) {
this.sumDirectoryContents = sumDirectoryContents;
}
/**
* Compares the length of two files.
*
* @param file1 The first file to compare
* @param file2 The second file to compare
* @return a negative value if the first file's length
* is less than the second, zero if the lengths are the
* same and a positive value if the first files length
* is greater than the second file.
*/
@Override
public int compare(final File file1, final File file2) {
final long size1;
if (file1.isDirectory()) {
size1 = sumDirectoryContents && file1.exists() ? FileUtils.sizeOfDirectory(file1) : 0;
} else {
size1 = file1.length();
}
final long size2;
if (file2.isDirectory()) {
size2 = sumDirectoryContents && file2.exists() ? FileUtils.sizeOfDirectory(file2) : 0;
} else {
size2 = file2.length();
}
final long result = size1 - size2;
if (result < 0) {
return -1;
}
if (result > 0) {
return 1;
}
return 0;
}
/**
* String representation of this file comparator.
*
* @return String representation of this file comparator
*/
@Override
public String toString() {
return super.toString() + "[sumDirectoryContents=" + sumDirectoryContents + "]";
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/comparator/package-info.java 0100644 0000000 0000000 00000017717 14603604450 031110 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/**
* Provides various {@link java.util.Comparator} implementations
* for {@link java.io.File}s and {@link java.nio.file.Path}.
* Sorting
*
* All the comparators include convenience utility sort(File...) and
* sort(List) methods.
*
*
* For example, to sort the files in a directory by name:
*
*
* File[] files = dir.listFiles();
* NameFileComparator.NAME_COMPARATOR.sort(files);
*
*
* ...alternatively you can do this in one line:
*
*
* File[] files = NameFileComparator.NAME_COMPARATOR.sort(dir.listFiles());
*
* Composite Comparator
*
* The CompositeFileComparator can be used
* to compare (and sort lists or arrays of files) by combining a number of other comparators.
*
*
* For example, to sort an array of files by type (i.e. directory or file)
* and then by name:
*
*
* CompositeFileComparator comparator =
* new CompositeFileComparator(
* DirectoryFileComparator.DIRECTORY_COMPARATOR,
* NameFileComparator.NAME_COMPARATOR);
* File[] files = dir.listFiles();
* comparator.sort(files);
*
* Singleton Instances (thread-safe)
*
* The {@link java.util.Comparator} implementations have some convenience
* singleton(thread-safe) instances ready to use:
*
*
*/
package org.apache.commons.io.comparator;
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/AccumulatorPathVisitor.java 0100644 0000000 0000000 00000017765 14603604450 032013 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import org.apache.commons.io.file.Counters.PathCounters;
import org.apache.commons.io.function.IOBiFunction;
/**
* Accumulates normalized paths during visitation.
*
* Use with care on large file trees as each visited Path element is remembered.
*
* Example
*
*
* Path dir = PathUtils.current();
* // We are interested in files older than one day
* Instant cutoff = Instant.now().minus(Duration.ofDays(1));
* AccumulatorPathVisitor visitor = AccumulatorPathVisitor.withLongCounters(new AgeFileFilter(cutoff));
* //
* // Walk one dir
* Files.walkFileTree(dir, Collections.emptySet(), 1, visitor);
* System.out.println(visitor.getPathCounters());
* System.out.println(visitor.getFileList());
* //
* visitor.getPathCounters().reset();
* //
* // Walk dir tree
* Files.walkFileTree(dir, visitor);
* System.out.println(visitor.getPathCounters());
* System.out.println(visitor.getDirList());
* System.out.println(visitor.getFileList());
*
*
* @since 2.7
*/
public class AccumulatorPathVisitor extends CountingPathVisitor {
/**
* Constructs a new instance configured with a BigInteger {@link PathCounters}.
*
* @return a new instance configured with a BigInteger {@link PathCounters}.
*/
public static AccumulatorPathVisitor withBigIntegerCounters() {
return new AccumulatorPathVisitor(Counters.bigIntegerPathCounters());
}
/**
* Constructs a new instance configured with a BigInteger {@link PathCounters}.
*
* @param fileFilter Filters files to accumulate and count.
* @param dirFilter Filters directories to accumulate and count.
* @return a new instance configured with a long {@link PathCounters}.
* @since 2.9.0
*/
public static AccumulatorPathVisitor withBigIntegerCounters(final PathFilter fileFilter,
final PathFilter dirFilter) {
return new AccumulatorPathVisitor(Counters.bigIntegerPathCounters(), fileFilter, dirFilter);
}
/**
* Constructs a new instance configured with a long {@link PathCounters}.
*
* @return a new instance configured with a long {@link PathCounters}.
*/
public static AccumulatorPathVisitor withLongCounters() {
return new AccumulatorPathVisitor(Counters.longPathCounters());
}
/**
* Constructs a new instance configured with a long {@link PathCounters}.
*
* @param fileFilter Filters files to accumulate and count.
* @param dirFilter Filters directories to accumulate and count.
* @return a new instance configured with a long {@link PathCounters}.
* @since 2.9.0
*/
public static AccumulatorPathVisitor withLongCounters(final PathFilter fileFilter, final PathFilter dirFilter) {
return new AccumulatorPathVisitor(Counters.longPathCounters(), fileFilter, dirFilter);
}
private final List dirList = new ArrayList<>();
private final List fileList = new ArrayList<>();
/**
* Constructs a new instance.
*
* @since 2.9.0
*/
public AccumulatorPathVisitor() {
super(Counters.noopPathCounters());
}
/**
* Constructs a new instance that counts file system elements.
*
* @param pathCounter How to count path visits.
*/
public AccumulatorPathVisitor(final PathCounters pathCounter) {
super(pathCounter);
}
/**
* Constructs a new instance.
*
* @param pathCounter How to count path visits.
* @param fileFilter Filters which files to count.
* @param dirFilter Filters which directories to count.
* @since 2.9.0
*/
public AccumulatorPathVisitor(final PathCounters pathCounter, final PathFilter fileFilter, final PathFilter dirFilter) {
super(pathCounter, fileFilter, dirFilter);
}
/**
* Constructs a new instance.
*
* @param pathCounter How to count path visits.
* @param fileFilter Filters which files to count.
* @param dirFilter Filters which directories to count.
* @param visitFileFailed Called on {@link #visitFileFailed(Path, IOException)}.
* @since 2.12.0
*/
public AccumulatorPathVisitor(final PathCounters pathCounter, final PathFilter fileFilter, final PathFilter dirFilter,
final IOBiFunction visitFileFailed) {
super(pathCounter, fileFilter, dirFilter, visitFileFailed);
}
private void add(final List list, final Path dir) {
list.add(dir.normalize());
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!super.equals(obj)) {
return false;
}
if (!(obj instanceof AccumulatorPathVisitor)) {
return false;
}
final AccumulatorPathVisitor other = (AccumulatorPathVisitor) obj;
return Objects.equals(dirList, other.dirList) && Objects.equals(fileList, other.fileList);
}
/**
* Gets a copy of the list of visited directories.
*
* @return a copy of the list of visited directories.
*/
public List getDirList() {
return new ArrayList<>(dirList);
}
/**
* Gets a copy of the list of visited files.
*
* @return a copy of the list of visited files.
*/
public List getFileList() {
return new ArrayList<>(fileList);
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + Objects.hash(dirList, fileList);
return result;
}
/**
* Relativizes each directory path with {@link Path#relativize(Path)} against the given {@code parent}, optionally
* sorting the result.
*
* @param parent A parent path
* @param sort Whether to sort
* @param comparator How to sort, null uses default sorting.
* @return A new list
*/
public List relativizeDirectories(final Path parent, final boolean sort,
final Comparator comparator) {
return PathUtils.relativize(getDirList(), parent, sort, comparator);
}
/**
* Relativizes each file path with {@link Path#relativize(Path)} against the given {@code parent}, optionally
* sorting the result.
*
* @param parent A parent path
* @param sort Whether to sort
* @param comparator How to sort, null uses default sorting.
* @return A new list
*/
public List relativizeFiles(final Path parent, final boolean sort,
final Comparator comparator) {
return PathUtils.relativize(getFileList(), parent, sort, comparator);
}
@Override
protected void updateDirCounter(final Path dir, final IOException exc) {
super.updateDirCounter(dir, exc);
add(dirList, dir);
}
@Override
protected void updateFileCounters(final Path file, final BasicFileAttributes attributes) {
super.updateFileCounters(file, attributes);
add(fileList, file);
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/CleaningPathVisitor.java 0100644 0000000 0000000 00000011556 14603604450 031244 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Arrays;
import java.util.Objects;
import org.apache.commons.io.file.Counters.PathCounters;
/**
* Deletes files but not directories as a visit proceeds.
*
* @since 2.7
*/
public class CleaningPathVisitor extends CountingPathVisitor {
/**
* Constructs a new instance configured with a BigInteger {@link PathCounters}.
*
* @return a new instance configured with a BigInteger {@link PathCounters}.
*/
public static CountingPathVisitor withBigIntegerCounters() {
return new CleaningPathVisitor(Counters.bigIntegerPathCounters());
}
/**
* Constructs a new instance configured with a long {@link PathCounters}.
*
* @return a new instance configured with a long {@link PathCounters}.
*/
public static CountingPathVisitor withLongCounters() {
return new CleaningPathVisitor(Counters.longPathCounters());
}
private final String[] skip;
private final boolean overrideReadOnly;
/**
* Constructs a new visitor that deletes files except for the files and directories explicitly given.
*
* @param pathCounter How to count visits.
* @param deleteOption How deletion is handled.
* @param skip The files to skip deleting.
* @since 2.8.0
*/
public CleaningPathVisitor(final PathCounters pathCounter, final DeleteOption[] deleteOption, final String... skip) {
super(pathCounter);
final String[] temp = skip != null ? skip.clone() : EMPTY_STRING_ARRAY;
Arrays.sort(temp);
this.skip = temp;
this.overrideReadOnly = StandardDeleteOption.overrideReadOnly(deleteOption);
}
/**
* Constructs a new visitor that deletes files except for the files and directories explicitly given.
*
* @param pathCounter How to count visits.
* @param skip The files to skip deleting.
*/
public CleaningPathVisitor(final PathCounters pathCounter, final String... skip) {
this(pathCounter, PathUtils.EMPTY_DELETE_OPTION_ARRAY, skip);
}
/**
* Returns true to process the given path, false if not.
*
* @param path the path to test.
* @return true to process the given path, false if not.
*/
private boolean accept(final Path path) {
return Arrays.binarySearch(skip, PathUtils.getFileNameString(path)) < 0;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!super.equals(obj)) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final CleaningPathVisitor other = (CleaningPathVisitor) obj;
return overrideReadOnly == other.overrideReadOnly && Arrays.equals(skip, other.skip);
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + Arrays.hashCode(skip);
result = prime * result + Objects.hash(overrideReadOnly);
return result;
}
@Override
public FileVisitResult preVisitDirectory(final Path dir, final BasicFileAttributes attributes) throws IOException {
super.preVisitDirectory(dir, attributes);
return accept(dir) ? FileVisitResult.CONTINUE : FileVisitResult.SKIP_SUBTREE;
}
@Override
public FileVisitResult visitFile(final Path file, final BasicFileAttributes attributes) throws IOException {
// Files.deleteIfExists() never follows links, so use LinkOption.NOFOLLOW_LINKS in other calls to Files.
if (accept(file) && Files.exists(file, LinkOption.NOFOLLOW_LINKS)) {
if (overrideReadOnly) {
PathUtils.setReadOnly(file, false, LinkOption.NOFOLLOW_LINKS);
}
Files.deleteIfExists(file);
}
updateFileCounters(file, attributes);
return FileVisitResult.CONTINUE;
}
} commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/CopyDirectoryVisitor.java 0100644 0000000 0000000 00000014344 14603604450 031504 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.io.IOException;
import java.nio.file.CopyOption;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.ProviderMismatchException;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Arrays;
import java.util.Objects;
import org.apache.commons.io.file.Counters.PathCounters;
/**
* Copies a source directory to a target directory.
*
* @since 2.7
*/
public class CopyDirectoryVisitor extends CountingPathVisitor {
private static CopyOption[] toCopyOption(final CopyOption... copyOptions) {
return copyOptions == null ? PathUtils.EMPTY_COPY_OPTIONS : copyOptions.clone();
}
private final CopyOption[] copyOptions;
private final Path sourceDirectory;
private final Path targetDirectory;
/**
* Constructs a new visitor that deletes files except for the files and directories explicitly given.
*
* @param pathCounter How to count visits.
* @param sourceDirectory The source directory
* @param targetDirectory The target directory
* @param copyOptions Specifies how the copying should be done.
*/
public CopyDirectoryVisitor(final PathCounters pathCounter, final Path sourceDirectory, final Path targetDirectory, final CopyOption... copyOptions) {
super(pathCounter);
this.sourceDirectory = sourceDirectory;
this.targetDirectory = targetDirectory;
this.copyOptions = toCopyOption(copyOptions);
}
/**
* Constructs a new visitor that deletes files except for the files and directories explicitly given.
*
* @param pathCounter How to count visits.
* @param fileFilter How to filter file paths.
* @param dirFilter How to filter directory paths.
* @param sourceDirectory The source directory
* @param targetDirectory The target directory
* @param copyOptions Specifies how the copying should be done.
* @since 2.9.0
*/
public CopyDirectoryVisitor(final PathCounters pathCounter, final PathFilter fileFilter, final PathFilter dirFilter, final Path sourceDirectory,
final Path targetDirectory, final CopyOption... copyOptions) {
super(pathCounter, fileFilter, dirFilter);
this.sourceDirectory = sourceDirectory;
this.targetDirectory = targetDirectory;
this.copyOptions = toCopyOption(copyOptions);
}
/**
* Copies the sourceFile to the targetFile.
*
* @param sourceFile the source file.
* @param targetFile the target file.
* @throws IOException if an I/O error occurs.
* @since 2.8.0
*/
protected void copy(final Path sourceFile, final Path targetFile) throws IOException {
Files.copy(sourceFile, targetFile, copyOptions);
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!super.equals(obj)) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final CopyDirectoryVisitor other = (CopyDirectoryVisitor) obj;
return Arrays.equals(copyOptions, other.copyOptions) && Objects.equals(sourceDirectory, other.sourceDirectory)
&& Objects.equals(targetDirectory, other.targetDirectory);
}
/**
* Gets the copy options.
*
* @return the copy options.
* @since 2.8.0
*/
public CopyOption[] getCopyOptions() {
return copyOptions.clone();
}
/**
* Gets the source directory.
*
* @return the source directory.
* @since 2.8.0
*/
public Path getSourceDirectory() {
return sourceDirectory;
}
/**
* Gets the target directory.
*
* @return the target directory.
* @since 2.8.0
*/
public Path getTargetDirectory() {
return targetDirectory;
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + Arrays.hashCode(copyOptions);
result = prime * result + Objects.hash(sourceDirectory, targetDirectory);
return result;
}
@Override
public FileVisitResult preVisitDirectory(final Path directory, final BasicFileAttributes attributes)
throws IOException {
final Path newTargetDir = resolveRelativeAsString(directory);
if (Files.notExists(newTargetDir)) {
Files.createDirectory(newTargetDir);
}
return super.preVisitDirectory(directory, attributes);
}
/**
* Relativizes against {@code sourceDirectory}, then resolves against {@code targetDirectory}.
*
* We have to call {@link Path#toString()} relative value because we cannot use paths belonging to different
* FileSystems in the Path methods, usually this leads to {@link ProviderMismatchException}.
*
* @param directory the directory to relativize.
* @return a new path, relativized against sourceDirectory, then resolved against targetDirectory.
*/
private Path resolveRelativeAsString(final Path directory) {
return targetDirectory.resolve(sourceDirectory.relativize(directory).toString());
}
@Override
public FileVisitResult visitFile(final Path sourceFile, final BasicFileAttributes attributes) throws IOException {
final Path targetFile = resolveRelativeAsString(sourceFile);
copy(sourceFile, targetFile);
return super.visitFile(targetFile, attributes);
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/Counters.java 0100644 0000000 0000000 00000025401 14603604450 027123 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.math.BigInteger;
import java.util.Objects;
/**
* Provides counters for files, directories, and sizes, as a visit proceeds.
*
* @since 2.7
*/
public class Counters {
/**
* Counts files, directories, and sizes, as a visit proceeds.
*/
private static class AbstractPathCounters implements PathCounters {
private final Counter byteCounter;
private final Counter directoryCounter;
private final Counter fileCounter;
/**
* Constructs a new instance.
*
* @param byteCounter the byte counter.
* @param directoryCounter the directory counter.
* @param fileCounter the file counter.
*/
protected AbstractPathCounters(final Counter byteCounter, final Counter directoryCounter, final Counter fileCounter) {
this.byteCounter = byteCounter;
this.directoryCounter = directoryCounter;
this.fileCounter = fileCounter;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof AbstractPathCounters)) {
return false;
}
final AbstractPathCounters other = (AbstractPathCounters) obj;
return Objects.equals(byteCounter, other.byteCounter)
&& Objects.equals(directoryCounter, other.directoryCounter)
&& Objects.equals(fileCounter, other.fileCounter);
}
@Override
public Counter getByteCounter() {
return byteCounter;
}
@Override
public Counter getDirectoryCounter() {
return directoryCounter;
}
/**
* Gets the count of visited files.
*
* @return the byte count of visited files.
*/
@Override
public Counter getFileCounter() {
return this.fileCounter;
}
@Override
public int hashCode() {
return Objects.hash(byteCounter, directoryCounter, fileCounter);
}
@Override
public void reset() {
byteCounter.reset();
directoryCounter.reset();
fileCounter.reset();
}
@Override
public String toString() {
return String.format("%,d files, %,d directories, %,d bytes", Long.valueOf(fileCounter.get()),
Long.valueOf(directoryCounter.get()), Long.valueOf(byteCounter.get()));
}
}
/**
* Counts using a {@link BigInteger} number.
*/
private static final class BigIntegerCounter implements Counter {
private BigInteger value = BigInteger.ZERO;
@Override
public void add(final long val) {
value = value.add(BigInteger.valueOf(val));
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Counter)) {
return false;
}
final Counter other = (Counter) obj;
return Objects.equals(value, other.getBigInteger());
}
@Override
public long get() {
return value.longValueExact();
}
@Override
public BigInteger getBigInteger() {
return value;
}
@Override
public Long getLong() {
return Long.valueOf(value.longValueExact());
}
@Override
public int hashCode() {
return Objects.hash(value);
}
@Override
public void increment() {
value = value.add(BigInteger.ONE);
}
@Override
public void reset() {
value = BigInteger.ZERO;
}
@Override
public String toString() {
return value.toString();
}
}
/**
* Counts files, directories, and sizes, as a visit proceeds, using BigInteger numbers.
*/
private final static class BigIntegerPathCounters extends AbstractPathCounters {
/**
* Constructs a new initialized instance.
*/
protected BigIntegerPathCounters() {
super(Counters.bigIntegerCounter(), Counters.bigIntegerCounter(), Counters.bigIntegerCounter());
}
}
/**
* Counts using a number.
*/
public interface Counter {
/**
* Adds the given number to this counter.
*
* @param val the value to add.
*/
void add(long val);
/**
* Gets the counter as a long.
*
* @return the counter as a long.
*/
long get();
/**
* Gets the counter as a BigInteger.
*
* @return the counter as a BigInteger.
*/
BigInteger getBigInteger();
/**
* Gets the counter as a Long.
*
* @return the counter as a Long.
*/
Long getLong();
/**
* Adds one to this counter.
*/
void increment();
/**
* Resets this count to 0.
*/
default void reset() {
// binary compat, do nothing
}
}
/**
* Counts using a {@code long} number.
*/
private final static class LongCounter implements Counter {
private long value;
@Override
public void add(final long add) {
value += add;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Counter)) {
return false;
}
final Counter other = (Counter) obj;
return value == other.get();
}
@Override
public long get() {
return value;
}
@Override
public BigInteger getBigInteger() {
return BigInteger.valueOf(value);
}
@Override
public Long getLong() {
return Long.valueOf(value);
}
@Override
public int hashCode() {
return Objects.hash(value);
}
@Override
public void increment() {
value++;
}
@Override
public void reset() {
value = 0L;
}
@Override
public String toString() {
return Long.toString(value);
}
}
/**
* Counts files, directories, and sizes, as a visit proceeds, using long numbers.
*/
private final static class LongPathCounters extends AbstractPathCounters {
/**
* Constructs a new initialized instance.
*/
protected LongPathCounters() {
super(Counters.longCounter(), Counters.longCounter(), Counters.longCounter());
}
}
/**
* Counts nothing.
*/
private final static class NoopCounter implements Counter {
static final NoopCounter INSTANCE = new NoopCounter();
@Override
public void add(final long add) {
// noop
}
@Override
public long get() {
return 0;
}
@Override
public BigInteger getBigInteger() {
return BigInteger.ZERO;
}
@Override
public Long getLong() {
return 0L;
}
@Override
public void increment() {
// noop
}
/**
* Returns {@code "0"}, always.
*
* @return {@code "0"}, always.
* @since 2.12.0
*/
@Override
public String toString() {
return "0";
}
}
/**
* Counts nothing.
*/
private static final class NoopPathCounters extends AbstractPathCounters {
static final NoopPathCounters INSTANCE = new NoopPathCounters();
/**
* Constructs a new initialized instance.
*/
private NoopPathCounters() {
super(Counters.noopCounter(), Counters.noopCounter(), Counters.noopCounter());
}
}
/**
* Counts files, directories, and sizes, as a visit proceeds.
*/
public interface PathCounters {
/**
* Gets the byte counter.
*
* @return the byte counter.
*/
Counter getByteCounter();
/**
* Gets the directory counter.
*
* @return the directory counter.
*/
Counter getDirectoryCounter();
/**
* Gets the file counter.
*
* @return the file counter.
*/
Counter getFileCounter();
/**
* Resets the counts to 0.
*/
default void reset() {
// binary compat, do nothing
}
}
/**
* Returns a new BigInteger Counter.
*
* @return a new BigInteger Counter.
*/
public static Counter bigIntegerCounter() {
return new BigIntegerCounter();
}
/**
* Returns a new BigInteger PathCounters.
*
* @return a new BigInteger PathCounters.
*/
public static PathCounters bigIntegerPathCounters() {
return new BigIntegerPathCounters();
}
/**
* Returns a new long Counter.
*
* @return a new long Counter.
*/
public static Counter longCounter() {
return new LongCounter();
}
/**
* Returns a new BigInteger PathCounters.
*
* @return a new BigInteger PathCounters.
*/
public static PathCounters longPathCounters() {
return new LongPathCounters();
}
/**
* Returns the no-op Counter.
*
* @return the no-op Counter.
* @since 2.9.0
*/
public static Counter noopCounter() {
return NoopCounter.INSTANCE;
}
/**
* Returns the no-op PathCounters.
*
* @return the no-op PathCounters.
* @since 2.9.0
*/
public static PathCounters noopPathCounters() {
return NoopPathCounters.INSTANCE;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/CountingPathVisitor.java 0100644 0000000 0000000 00000014715 14603604450 031312 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Objects;
import org.apache.commons.io.file.Counters.PathCounters;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.SymbolicLinkFileFilter;
import org.apache.commons.io.filefilter.TrueFileFilter;
import org.apache.commons.io.function.IOBiFunction;
/**
* Counts files, directories, and sizes, as a visit proceeds.
*
* @since 2.7
*/
public class CountingPathVisitor extends SimplePathVisitor {
static final String[] EMPTY_STRING_ARRAY = {};
static IOFileFilter defaultDirFilter() {
return TrueFileFilter.INSTANCE;
}
static IOFileFilter defaultFileFilter() {
return new SymbolicLinkFileFilter(FileVisitResult.TERMINATE, FileVisitResult.CONTINUE);
}
/**
* Constructs a new instance configured with a {@link BigInteger} {@link PathCounters}.
*
* @return a new instance configured with a {@link BigInteger} {@link PathCounters}.
*/
public static CountingPathVisitor withBigIntegerCounters() {
return new CountingPathVisitor(Counters.bigIntegerPathCounters());
}
/**
* Constructs a new instance configured with a {@code long} {@link PathCounters}.
*
* @return a new instance configured with a {@code long} {@link PathCounters}.
*/
public static CountingPathVisitor withLongCounters() {
return new CountingPathVisitor(Counters.longPathCounters());
}
private final PathCounters pathCounters;
private final PathFilter fileFilter;
private final PathFilter dirFilter;
/**
* Constructs a new instance.
*
* @param pathCounter How to count path visits.
*/
public CountingPathVisitor(final PathCounters pathCounter) {
this(pathCounter, defaultFileFilter(), defaultDirFilter());
}
/**
* Constructs a new instance.
*
* @param pathCounter How to count path visits.
* @param fileFilter Filters which files to count.
* @param dirFilter Filters which directories to count.
* @since 2.9.0
*/
public CountingPathVisitor(final PathCounters pathCounter, final PathFilter fileFilter, final PathFilter dirFilter) {
this.pathCounters = Objects.requireNonNull(pathCounter, "pathCounter");
this.fileFilter = Objects.requireNonNull(fileFilter, "fileFilter");
this.dirFilter = Objects.requireNonNull(dirFilter, "dirFilter");
}
/**
* Constructs a new instance.
*
* @param pathCounter How to count path visits.
* @param fileFilter Filters which files to count.
* @param dirFilter Filters which directories to count.
* @param visitFileFailed Called on {@link #visitFileFailed(Path, IOException)}.
* @since 2.12.0
*/
public CountingPathVisitor(final PathCounters pathCounter, final PathFilter fileFilter, final PathFilter dirFilter,
final IOBiFunction visitFileFailed) {
super(visitFileFailed);
this.pathCounters = Objects.requireNonNull(pathCounter, "pathCounter");
this.fileFilter = Objects.requireNonNull(fileFilter, "fileFilter");
this.dirFilter = Objects.requireNonNull(dirFilter, "dirFilter");
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof CountingPathVisitor)) {
return false;
}
final CountingPathVisitor other = (CountingPathVisitor) obj;
return Objects.equals(pathCounters, other.pathCounters);
}
/**
* Gets the visitation counts.
*
* @return the visitation counts.
*/
public PathCounters getPathCounters() {
return pathCounters;
}
@Override
public int hashCode() {
return Objects.hash(pathCounters);
}
@Override
public FileVisitResult postVisitDirectory(final Path dir, final IOException exc) throws IOException {
updateDirCounter(dir, exc);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult preVisitDirectory(final Path dir, final BasicFileAttributes attributes) throws IOException {
final FileVisitResult accept = dirFilter.accept(dir, attributes);
return accept != FileVisitResult.CONTINUE ? FileVisitResult.SKIP_SUBTREE : FileVisitResult.CONTINUE;
}
@Override
public String toString() {
return pathCounters.toString();
}
/**
* Updates the counter for visiting the given directory.
*
* @param dir the visited directory.
* @param exc Encountered exception.
* @since 2.9.0
*/
protected void updateDirCounter(final Path dir, final IOException exc) {
pathCounters.getDirectoryCounter().increment();
}
/**
* Updates the counters for visiting the given file.
*
* @param file the visited file.
* @param attributes the visited file attributes.
*/
protected void updateFileCounters(final Path file, final BasicFileAttributes attributes) {
pathCounters.getFileCounter().increment();
pathCounters.getByteCounter().add(attributes.size());
}
@Override
public FileVisitResult visitFile(final Path file, final BasicFileAttributes attributes) throws IOException {
// Note: A file can be a symbolic link to a directory.
if (Files.exists(file) && fileFilter.accept(file, attributes) == FileVisitResult.CONTINUE) {
updateFileCounters(file, attributes);
}
return FileVisitResult.CONTINUE;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/DeleteOption.java 0100644 0000000 0000000 00000002110 14603604450 027704 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
/**
* An object that configures how to delete a file.
*
*
* The {@link StandardDeleteOption} enumeration type defines our standard options.
*
*
* @see StandardDeleteOption
* @since 2.8.0
*/
public interface DeleteOption {
// empty
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/DeletingPathVisitor.java 0100644 0000000 0000000 00000014542 14603604450 031255 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Arrays;
import java.util.Objects;
import org.apache.commons.io.file.Counters.PathCounters;
/**
* Deletes files and directories as a visit proceeds.
*
* @since 2.7
*/
public class DeletingPathVisitor extends CountingPathVisitor {
/**
* Constructs a new instance configured with a BigInteger {@link PathCounters}.
*
* @return a new instance configured with a BigInteger {@link PathCounters}.
*/
public static DeletingPathVisitor withBigIntegerCounters() {
return new DeletingPathVisitor(Counters.bigIntegerPathCounters());
}
/**
* Constructs a new instance configured with a long {@link PathCounters}.
*
* @return a new instance configured with a long {@link PathCounters}.
*/
public static DeletingPathVisitor withLongCounters() {
return new DeletingPathVisitor(Counters.longPathCounters());
}
private final String[] skip;
private final boolean overrideReadOnly;
private final LinkOption[] linkOptions;
/**
* Constructs a new visitor that deletes files except for the files and directories explicitly given.
*
* @param pathCounter How to count visits.
* @param deleteOption How deletion is handled.
* @param skip The files to skip deleting.
* @since 2.8.0
*/
public DeletingPathVisitor(final PathCounters pathCounter, final DeleteOption[] deleteOption, final String... skip) {
this(pathCounter, PathUtils.noFollowLinkOptionArray(), deleteOption, skip);
}
/**
* Constructs a new visitor that deletes files except for the files and directories explicitly given.
*
* @param pathCounter How to count visits.
* @param linkOptions How symbolic links are handled.
* @param deleteOption How deletion is handled.
* @param skip The files to skip deleting.
* @since 2.9.0
*/
public DeletingPathVisitor(final PathCounters pathCounter, final LinkOption[] linkOptions, final DeleteOption[] deleteOption, final String... skip) {
super(pathCounter);
final String[] temp = skip != null ? skip.clone() : EMPTY_STRING_ARRAY;
Arrays.sort(temp);
this.skip = temp;
this.overrideReadOnly = StandardDeleteOption.overrideReadOnly(deleteOption);
// TODO Files.deleteIfExists() never follows links, so use LinkOption.NOFOLLOW_LINKS in other calls to Files.
this.linkOptions = linkOptions == null ? PathUtils.noFollowLinkOptionArray() : linkOptions.clone();
}
/**
* Constructs a new visitor that deletes files except for the files and directories explicitly given.
*
* @param pathCounter How to count visits.
*
* @param skip The files to skip deleting.
*/
public DeletingPathVisitor(final PathCounters pathCounter, final String... skip) {
this(pathCounter, PathUtils.EMPTY_DELETE_OPTION_ARRAY, skip);
}
/**
* Returns true to process the given path, false if not.
*
* @param path the path to test.
* @return true to process the given path, false if not.
*/
private boolean accept(final Path path) {
return Arrays.binarySearch(skip, PathUtils.getFileNameString(path)) < 0;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!super.equals(obj)) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final DeletingPathVisitor other = (DeletingPathVisitor) obj;
return overrideReadOnly == other.overrideReadOnly && Arrays.equals(skip, other.skip);
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + Arrays.hashCode(skip);
result = prime * result + Objects.hash(overrideReadOnly);
return result;
}
@Override
public FileVisitResult postVisitDirectory(final Path dir, final IOException exc) throws IOException {
if (PathUtils.isEmptyDirectory(dir)) {
Files.deleteIfExists(dir);
}
return super.postVisitDirectory(dir, exc);
}
@Override
public FileVisitResult preVisitDirectory(final Path dir, final BasicFileAttributes attrs) throws IOException {
super.preVisitDirectory(dir, attrs);
return accept(dir) ? FileVisitResult.CONTINUE : FileVisitResult.SKIP_SUBTREE;
}
@Override
public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) throws IOException {
if (accept(file)) {
// delete files and valid links, respecting linkOptions
if (Files.exists(file, linkOptions)) {
if (overrideReadOnly) {
PathUtils.setReadOnly(file, false, linkOptions);
}
Files.deleteIfExists(file);
}
// invalid links will survive previous delete, different approach needed:
if (Files.isSymbolicLink(file)) {
try {
// deleteIfExists does not work for this case
Files.delete(file);
} catch (final NoSuchFileException ignored) {
// ignore
}
}
}
updateFileCounters(file, attrs);
return FileVisitResult.CONTINUE;
}
} commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/DirectoryStreamFilter.java 0100644 0000000 0000000 00000004174 14603604450 031613 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.FileVisitResult;
import java.nio.file.Path;
import java.util.Objects;
/**
* A {@link java.nio.file.DirectoryStream.Filter DirectoryStream.Filter} that delegates to a {@link PathFilter}.
*
* You pass this filter to {@link java.nio.file.Files#newDirectoryStream(Path, DirectoryStream.Filter)
* Files#newDirectoryStream(Path, DirectoryStream.Filter)}.
*
*
* @since 2.9.0
*/
public class DirectoryStreamFilter implements DirectoryStream.Filter {
private final PathFilter pathFilter;
/**
* Constructs a new instance for the given path filter.
*
* @param pathFilter How to filter paths.
*/
public DirectoryStreamFilter(final PathFilter pathFilter) {
// TODO Instead of NPE, we could map null to FalseFileFilter.
this.pathFilter = Objects.requireNonNull(pathFilter, "pathFilter");
}
@Override
public boolean accept(final Path path) throws IOException {
return pathFilter.accept(path, PathUtils.readBasicFileAttributes(path, PathUtils.EMPTY_LINK_OPTION_ARRAY)) == FileVisitResult.CONTINUE;
}
/**
* Gets the path filter.
*
* @return the path filter.
*/
public PathFilter getPathFilter() {
return pathFilter;
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/FilesUncheck.java 0100644 0000000 0000000 00000075761 14603604450 027702 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.UncheckedIOException;
import java.nio.channels.SeekableByteChannel;
import java.nio.charset.Charset;
import java.nio.file.CopyOption;
import java.nio.file.DirectoryStream;
import java.nio.file.FileStore;
import java.nio.file.FileVisitOption;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileAttribute;
import java.nio.file.attribute.FileTime;
import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.UserPrincipal;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BiPredicate;
import java.util.stream.Stream;
import org.apache.commons.io.function.Uncheck;
/**
* Delegates to {@link Files} to uncheck calls by throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* @see Files
* @see IOException
* @see UncheckedIOException
* @since 2.12.0
*/
public final class FilesUncheck {
/**
* Delegates to {@link Files#copy(InputStream, Path, CopyOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param in See delegate.
* @param target See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
* @see Files#copy(InputStream, Path,CopyOption...)
*/
public static long copy(final InputStream in, final Path target, final CopyOption... options) {
return Uncheck.apply(Files::copy, in, target, options);
}
/**
* Delegates to {@link Files#copy(Path, OutputStream)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param source See delegate. See delegate.
* @param out See delegate. See delegate.
* @return See delegate. See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static long copy(final Path source, final OutputStream out) {
return Uncheck.apply(Files::copy, source, out);
}
/**
* Delegates to {@link Files#copy(Path, Path, CopyOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param source See delegate.
* @param target See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path copy(final Path source, final Path target, final CopyOption... options) {
return Uncheck.apply(Files::copy, source, target, options);
}
/**
* Delegates to {@link Files#createDirectories(Path, FileAttribute...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param dir See delegate.
* @param attrs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path createDirectories(final Path dir, final FileAttribute... attrs) {
return Uncheck.apply(Files::createDirectories, dir, attrs);
}
/**
* Delegates to {@link Files#createDirectory(Path, FileAttribute...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param dir See delegate.
* @param attrs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path createDirectory(final Path dir, final FileAttribute... attrs) {
return Uncheck.apply(Files::createDirectory, dir, attrs);
}
/**
* Delegates to {@link Files#createFile(Path, FileAttribute...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param attrs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path createFile(final Path path, final FileAttribute... attrs) {
return Uncheck.apply(Files::createFile, path, attrs);
}
/**
* Delegates to {@link Files#createLink(Path, Path)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param link See delegate.
* @param existing See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path createLink(final Path link, final Path existing) {
return Uncheck.apply(Files::createLink, link, existing);
}
/**
* Delegates to {@link Files#createSymbolicLink(Path, Path, FileAttribute...)} throwing {@link UncheckedIOException}
* instead of {@link IOException}.
*
* @param link See delegate.
* @param target See delegate.
* @param attrs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path createSymbolicLink(final Path link, final Path target, final FileAttribute... attrs) {
return Uncheck.apply(Files::createSymbolicLink, link, target, attrs);
}
/**
* Delegates to {@link Files#createTempDirectory(Path, String, FileAttribute...)} throwing {@link UncheckedIOException}
* instead of {@link IOException}.
*
* @param dir See delegate.
* @param prefix See delegate.
* @param attrs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path createTempDirectory(final Path dir, final String prefix, final FileAttribute... attrs) {
return Uncheck.apply(Files::createTempDirectory, dir, prefix, attrs);
}
/**
* Delegates to {@link Files#createTempDirectory(String, FileAttribute...)} throwing {@link UncheckedIOException}
* instead of {@link IOException}.
*
* @param prefix See delegate.
* @param attrs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path createTempDirectory(final String prefix, final FileAttribute... attrs) {
return Uncheck.apply(Files::createTempDirectory, prefix, attrs);
}
/**
* Delegates to {@link Files#createTempFile(Path, String, String, FileAttribute...)} throwing
* {@link UncheckedIOException} instead of {@link IOException}.
*
* @param dir See delegate.
* @param prefix See delegate.
* @param suffix See delegate.
* @param attrs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path createTempFile(final Path dir, final String prefix, final String suffix, final FileAttribute... attrs) {
return Uncheck.apply(Files::createTempFile, dir, prefix, suffix, attrs);
}
/**
* Delegates to {@link Files#createTempFile(String, String, FileAttribute...)} throwing {@link UncheckedIOException}
* instead of {@link IOException}.
*
* @param prefix See delegate.
* @param suffix See delegate.
* @param attrs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path createTempFile(final String prefix, final String suffix, final FileAttribute... attrs) {
return Uncheck.apply(Files::createTempFile, prefix, suffix, attrs);
}
/**
* Delegates to {@link Files#delete(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* @param path See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static void delete(final Path path) {
Uncheck.accept(Files::delete, path);
}
/**
* Delegates to {@link Files#deleteIfExists(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* @param path See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static boolean deleteIfExists(final Path path) {
return Uncheck.apply(Files::deleteIfExists, path);
}
/**
* Delegates to {@link Files#find(Path, int, BiPredicate, FileVisitOption...)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* The returned {@link Stream} wraps a {@link DirectoryStream}. When you require timely disposal of file system resources, use a {@code try}-with-resources
* block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed.
*
*
* @param start See delegate.
* @param maxDepth See delegate.
* @param matcher See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
* @since 2.14.0
*/
public static Stream find(final Path start, final int maxDepth, final BiPredicate matcher,
final FileVisitOption... options) {
return Uncheck.apply(Files::find, start, maxDepth, matcher, options);
}
/**
* Delegates to {@link Files#getAttribute(Path, String, LinkOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param attribute See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Object getAttribute(final Path path, final String attribute, final LinkOption... options) {
return Uncheck.apply(Files::getAttribute, path, attribute, options);
}
/**
* Delegates to {@link Files#getFileStore(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* @param path See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static FileStore getFileStore(final Path path) {
return Uncheck.apply(Files::getFileStore, path);
}
/**
* Delegates to {@link Files#getLastModifiedTime(Path, LinkOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static FileTime getLastModifiedTime(final Path path, final LinkOption... options) {
return Uncheck.apply(Files::getLastModifiedTime, path, options);
}
/**
* Delegates to {@link Files#getOwner(Path, LinkOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static UserPrincipal getOwner(final Path path, final LinkOption... options) {
return Uncheck.apply(Files::getOwner, path, options);
}
/**
* Delegates to {@link Files#getPosixFilePermissions(Path, LinkOption...)} throwing {@link UncheckedIOException} instead
* of {@link IOException}.
*
* @param path See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Set getPosixFilePermissions(final Path path, final LinkOption... options) {
return Uncheck.apply(Files::getPosixFilePermissions, path, options);
}
/**
* Delegates to {@link Files#isHidden(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* @param path See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static boolean isHidden(final Path path) {
return Uncheck.apply(Files::isHidden, path);
}
/**
* Delegates to {@link Files#isSameFile(Path, Path)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param path2 See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static boolean isSameFile(final Path path, final Path path2) {
return Uncheck.apply(Files::isSameFile, path, path2);
}
/**
* Delegates to {@link Files#lines(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* The returned {@link Stream} wraps a {@link Reader}. When you require timely disposal of file system resources, use a {@code try}-with-resources block to
* ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed.
*
*
* @param path See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Stream lines(final Path path) {
return Uncheck.apply(Files::lines, path);
}
/**
* Delegates to {@link Files#lines(Path, Charset)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* The returned {@link Stream} wraps a {@link Reader}. When you require timely disposal of file system resources, use a {@code try}-with-resources block to
* ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed.
*
*
* @param path See delegate.
* @param cs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Stream lines(final Path path, final Charset cs) {
return Uncheck.apply(Files::lines, path, cs);
}
/**
* Delegates to {@link Files#list(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* The returned {@link Stream} wraps a {@link DirectoryStream}. When you require timely disposal of file system resources, use a {@code try}-with-resources
* block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed.
*
*
* @param dir See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Stream list(final Path dir) {
return Uncheck.apply(Files::list, dir);
}
/**
* Delegates to {@link Files#move(Path, Path, CopyOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param source See delegate.
* @param target See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static Path move(final Path source, final Path target, final CopyOption... options) {
return Uncheck.apply(Files::move, source, target, options);
}
/**
* Delegates to {@link Files#newBufferedReader(Path)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static BufferedReader newBufferedReader(final Path path) {
return Uncheck.apply(Files::newBufferedReader, path);
}
/**
* Delegates to {@link Files#newBufferedReader(Path, Charset)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param cs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static BufferedReader newBufferedReader(final Path path, final Charset cs) {
return Uncheck.apply(Files::newBufferedReader, path, cs);
}
/**
* Delegates to {@link Files#newBufferedWriter(Path, Charset, OpenOption...)} throwing {@link UncheckedIOException}
* instead of {@link IOException}.
*
* @param path See delegate.
* @param cs See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static BufferedWriter newBufferedWriter(final Path path, final Charset cs, final OpenOption... options) {
return Uncheck.apply(Files::newBufferedWriter, path, cs, options);
}
/**
* Delegates to {@link Files#newBufferedWriter(Path, OpenOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static BufferedWriter newBufferedWriter(final Path path, final OpenOption... options) {
return Uncheck.apply(Files::newBufferedWriter, path, options);
}
/**
* Delegates to {@link Files#newByteChannel(Path, OpenOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param options See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static SeekableByteChannel newByteChannel(final Path path, final OpenOption... options) {
return Uncheck.apply(Files::newByteChannel, path, options);
}
/**
* Delegates to {@link Files#newByteChannel(Path, Set, FileAttribute...)} throwing {@link UncheckedIOException} instead
* of {@link IOException}.
*
* @param path See delegate.
* @param options See delegate.
* @param attrs See delegate.
* @return See delegate.
* @throws UncheckedIOException Wraps an {@link IOException}.
*/
public static SeekableByteChannel newByteChannel(final Path path, final Set options, final FileAttribute... attrs) {
return Uncheck.apply(Files::newByteChannel, path, options, attrs);
}
/**
* Delegates to {@link Files#newDirectoryStream(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* If you don't use the try-with-resources construct, then you must call the stream's {@link Stream#close()} method after iteration is complete to free any
* resources held for the open directory.
*
*
* @param dir See delegate.
* @return See delegate.
*/
public static DirectoryStream newDirectoryStream(final Path dir) {
return Uncheck.apply(Files::newDirectoryStream, dir);
}
/**
* Delegates to {@link Files#newDirectoryStream(Path, java.nio.file.DirectoryStream.Filter)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* If you don't use the try-with-resources construct, then you must call the stream's {@link Stream#close()} method after iteration is complete to free any
* resources held for the open directory.
*
*
* @param dir See delegate.
* @param filter See delegate.
* @return See delegate.
*/
public static DirectoryStream newDirectoryStream(final Path dir, final DirectoryStream.Filter filter) {
return Uncheck.apply(Files::newDirectoryStream, dir, filter);
}
/**
* Delegates to {@link Files#newDirectoryStream(Path, String)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* The returned {@link Stream} wraps a {@link DirectoryStream}. When you require timely disposal of file system resources, use a {@code try}-with-resources
* block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed.
*
*
* @param dir See delegate.
* @param glob See delegate.
* @return See delegate.
*/
public static DirectoryStream newDirectoryStream(final Path dir, final String glob) {
return Uncheck.apply(Files::newDirectoryStream, dir, glob);
}
/**
* Delegates to {@link Files#newInputStream(Path, OpenOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param options See delegate.
* @return See delegate.
*/
public static InputStream newInputStream(final Path path, final OpenOption... options) {
return Uncheck.apply(Files::newInputStream, path, options);
}
/**
* Delegates to {@link Files#newOutputStream(Path, OpenOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param options See delegate.
* @return See delegate.
*/
public static OutputStream newOutputStream(final Path path, final OpenOption... options) {
return Uncheck.apply(Files::newOutputStream, path, options);
}
/**
* Delegates to {@link Files#probeContentType(Path)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @return See delegate.
*/
public static String probeContentType(final Path path) {
return Uncheck.apply(Files::probeContentType, path);
}
/**
* Delegates to {@link Files#readAllBytes(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* @param path See delegate.
* @return See delegate.
*/
public static byte[] readAllBytes(final Path path) {
return Uncheck.apply(Files::readAllBytes, path);
}
/**
* Delegates to {@link Files#readAllLines(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* @param path See delegate.
* @return See delegate.
*/
public static List readAllLines(final Path path) {
return Uncheck.apply(Files::readAllLines, path);
}
/**
* Delegates to {@link Files#readAllLines(Path, Charset)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param cs See delegate.
* @return See delegate.
*/
public static List readAllLines(final Path path, final Charset cs) {
return Uncheck.apply(Files::readAllLines, path, cs);
}
/**
* Delegates to {@link Files#readAttributes(Path, Class, LinkOption...)} throwing {@link UncheckedIOException} instead
* of {@link IOException}.
*
* @param See delegate.
* @param path See delegate.
* @param type See delegate.
* @param options See delegate.
* @return See delegate.
*/
public static A readAttributes(final Path path, final Class type, final LinkOption... options) {
return Uncheck.apply(Files::readAttributes, path, type, options);
}
/**
* Delegates to {@link Files#readAttributes(Path, String, LinkOption...)} throwing {@link UncheckedIOException} instead
* of {@link IOException}.
*
* @param path See delegate.
* @param attributes See delegate.
* @param options See delegate.
* @return See delegate.
*/
public static Map readAttributes(final Path path, final String attributes, final LinkOption... options) {
return Uncheck.apply(Files::readAttributes, path, attributes, options);
}
/**
* Delegates to {@link Files#readSymbolicLink(Path)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param link See delegate.
* @return See delegate.
*/
public static Path readSymbolicLink(final Path link) {
return Uncheck.apply(Files::readSymbolicLink, link);
}
/**
* Delegates to {@link Files#setAttribute(Path, String, Object, LinkOption...)} throwing {@link UncheckedIOException}
* instead of {@link IOException}.
*
* @param path See delegate.
* @param attribute See delegate.
* @param value See delegate.
* @param options See delegate.
* @return See delegate.
*/
public static Path setAttribute(final Path path, final String attribute, final Object value, final LinkOption... options) {
return Uncheck.apply(Files::setAttribute, path, attribute, value, options);
}
/**
* Delegates to {@link Files#setLastModifiedTime(Path, FileTime)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param time See delegate.
* @return See delegate.
*/
public static Path setLastModifiedTime(final Path path, final FileTime time) {
return Uncheck.apply(Files::setLastModifiedTime, path, time);
}
/**
* Delegates to {@link Files#setOwner(Path, UserPrincipal)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param owner See delegate.
* @return See delegate.
*/
public static Path setOwner(final Path path, final UserPrincipal owner) {
return Uncheck.apply(Files::setOwner, path, owner);
}
/**
* Delegates to {@link Files#setPosixFilePermissions(Path, Set)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param perms See delegate.
* @return See delegate.
*/
public static Path setPosixFilePermissions(final Path path, final Set perms) {
return Uncheck.apply(Files::setPosixFilePermissions, path, perms);
}
/**
* Delegates to {@link Files#size(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* @param path See delegate.
* @return See delegate.
*/
public static long size(final Path path) {
return Uncheck.apply(Files::size, path);
}
/**
* Delegates to {@link Files#walk(Path, FileVisitOption...)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* The returned {@link Stream} may wrap one or more {@link DirectoryStream}s. When you require timely disposal of file system resources, use a
* {@code try}-with-resources block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed. Calling a
* closed stream causes a {@link IllegalStateException}.
*
*
* @param start See delegate.
* @param options See delegate.
* @return See delegate.
*/
public static Stream walk(final Path start, final FileVisitOption... options) {
return Uncheck.apply(Files::walk, start, options);
}
/**
* Delegates to {@link Files#walk(Path, int, FileVisitOption...)} throwing {@link UncheckedIOException} instead of {@link IOException}.
*
* The returned {@link Stream} may wrap one or more {@link DirectoryStream}s. When you require timely disposal of file system resources, use a
* {@code try}-with-resources block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed. Calling a
* closed stream causes a {@link IllegalStateException}.
*
*
* @param start See delegate.
* @param maxDepth See delegate.
* @param options See delegate.
* @return See delegate.
*/
public static Stream walk(final Path start, final int maxDepth, final FileVisitOption... options) {
return Uncheck.apply(Files::walk, start, maxDepth, options);
}
/**
* Delegates to {@link Files#walkFileTree(Path, FileVisitor)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param start See delegate.
* @param visitor See delegate.
* @return See delegate.
*/
public static Path walkFileTree(final Path start, final FileVisitor visitor) {
return Uncheck.apply(Files::walkFileTree, start, visitor);
}
/**
* Delegates to {@link Files#walkFileTree(Path, Set, int, FileVisitor)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param start See delegate.
* @param options See delegate.
* @param maxDepth See delegate.
* @param visitor See delegate.
* @return See delegate.
*/
public static Path walkFileTree(final Path start, final Set options, final int maxDepth, final FileVisitor visitor) {
return Uncheck.apply(Files::walkFileTree, start, options, maxDepth, visitor);
}
/**
* Delegates to {@link Files#write(Path, byte[], OpenOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param bytes See delegate.
* @param options See delegate.
* @return See delegate.
*/
public static Path write(final Path path, final byte[] bytes, final OpenOption... options) {
return Uncheck.apply(Files::write, path, bytes, options);
}
/**
* Delegates to {@link Files#write(Path, Iterable, Charset, OpenOption...)} throwing {@link UncheckedIOException}
* instead of {@link IOException}.
*
* @param path See delegate.
* @param lines See delegate.
* @param cs See delegate.
* @param options See delegate.
* @return See delegate.
*/
public static Path write(final Path path, final Iterable lines, final Charset cs, final OpenOption... options) {
return Uncheck.apply(Files::write, path, lines, cs, options);
}
/**
* Delegates to {@link Files#write(Path, Iterable, OpenOption...)} throwing {@link UncheckedIOException} instead of
* {@link IOException}.
*
* @param path See delegate.
* @param lines See delegate.
* @param options See delegate.
* @return See delegate.
*/
public static Path write(final Path path, final Iterable lines, final OpenOption... options) {
return Uncheck.apply(Files::write, path, lines, options);
}
/**
* No instances.
*/
private FilesUncheck() {
// No instances
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/NoopPathVisitor.java 0100644 0000000 0000000 00000003113 14603604450 030425 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Path;
import org.apache.commons.io.function.IOBiFunction;
/**
* A noop path visitor.
*
* @since 2.9.0
*/
public class NoopPathVisitor extends SimplePathVisitor {
/**
* The singleton instance.
*/
public static final NoopPathVisitor INSTANCE = new NoopPathVisitor();
/**
* Constructs a new instance.
*/
public NoopPathVisitor() {
}
/**
* Constructs a new instance.
*
* @param visitFileFailed Called on {@link #visitFileFailed(Path, IOException)}.
* @since 2.12.0
*/
public NoopPathVisitor(final IOBiFunction visitFileFailed) {
super(visitFileFailed);
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/PathFilter.java 0100644 0000000 0000000 00000002543 14603604450 027365 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.nio.file.FileVisitResult;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
/**
* A filter for {@link Path}s.
*
* @since 2.9.0
*/
@FunctionalInterface
public interface PathFilter {
/**
* Tests whether or not to include the specified Path in a result.
*
* @param path The Path to test.
* @param attributes the file's basic attributes (TODO may be null).
* @return a FileVisitResult
*/
FileVisitResult accept(Path path, BasicFileAttributes attributes);
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/PathUtils.java 0100644 0000000 0000000 00000245170 14603604450 027245 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.math.BigInteger;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.file.AccessDeniedException;
import java.nio.file.CopyOption;
import java.nio.file.DirectoryStream;
import java.nio.file.FileVisitOption;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.NoSuchFileException;
import java.nio.file.NotDirectoryException;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.nio.file.attribute.AclEntry;
import java.nio.file.attribute.AclFileAttributeView;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.DosFileAttributeView;
import java.nio.file.attribute.DosFileAttributes;
import java.nio.file.attribute.FileAttribute;
import java.nio.file.attribute.FileTime;
import java.nio.file.attribute.PosixFileAttributeView;
import java.nio.file.attribute.PosixFileAttributes;
import java.nio.file.attribute.PosixFilePermission;
import java.time.Duration;
import java.time.Instant;
import java.time.chrono.ChronoZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.io.Charsets;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.RandomAccessFileMode;
import org.apache.commons.io.RandomAccessFiles;
import org.apache.commons.io.ThreadUtils;
import org.apache.commons.io.file.Counters.PathCounters;
import org.apache.commons.io.file.attribute.FileTimes;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.function.IOFunction;
import org.apache.commons.io.function.IOSupplier;
/**
* NIO Path utilities.
*
* @since 2.7
*/
public final class PathUtils {
/**
* Private worker/holder that computes and tracks relative path names and their equality. We reuse the sorted relative lists when comparing directories.
*/
private static final class RelativeSortedPaths {
final boolean equals;
// final List relativeDirList1; // might need later?
// final List relativeDirList2; // might need later?
final List relativeFileList1;
final List relativeFileList2;
/**
* Constructs and initializes a new instance by accumulating directory and file info.
*
* @param dir1 First directory to compare.
* @param dir2 Seconds directory to compare.
* @param maxDepth See {@link Files#walkFileTree(Path,Set,int,FileVisitor)}.
* @param linkOptions Options indicating how symbolic links are handled.
* @param fileVisitOptions See {@link Files#walkFileTree(Path,Set,int,FileVisitor)}.
* @throws IOException if an I/O error is thrown by a visitor method.
*/
private RelativeSortedPaths(final Path dir1, final Path dir2, final int maxDepth, final LinkOption[] linkOptions,
final FileVisitOption[] fileVisitOptions) throws IOException {
final List tmpRelativeDirList1;
final List tmpRelativeDirList2;
List tmpRelativeFileList1 = null;
List tmpRelativeFileList2 = null;
if (dir1 == null && dir2 == null) {
equals = true;
} else if (dir1 == null ^ dir2 == null) {
equals = false;
} else {
final boolean parentDirNotExists1 = Files.notExists(dir1, linkOptions);
final boolean parentDirNotExists2 = Files.notExists(dir2, linkOptions);
if (parentDirNotExists1 || parentDirNotExists2) {
equals = parentDirNotExists1 && parentDirNotExists2;
} else {
final AccumulatorPathVisitor visitor1 = accumulate(dir1, maxDepth, fileVisitOptions);
final AccumulatorPathVisitor visitor2 = accumulate(dir2, maxDepth, fileVisitOptions);
if (visitor1.getDirList().size() != visitor2.getDirList().size() || visitor1.getFileList().size() != visitor2.getFileList().size()) {
equals = false;
} else {
tmpRelativeDirList1 = visitor1.relativizeDirectories(dir1, true, null);
tmpRelativeDirList2 = visitor2.relativizeDirectories(dir2, true, null);
if (!tmpRelativeDirList1.equals(tmpRelativeDirList2)) {
equals = false;
} else {
tmpRelativeFileList1 = visitor1.relativizeFiles(dir1, true, null);
tmpRelativeFileList2 = visitor2.relativizeFiles(dir2, true, null);
equals = tmpRelativeFileList1.equals(tmpRelativeFileList2);
}
}
}
}
// relativeDirList1 = tmpRelativeDirList1;
// relativeDirList2 = tmpRelativeDirList2;
relativeFileList1 = tmpRelativeFileList1;
relativeFileList2 = tmpRelativeFileList2;
}
}
private static final OpenOption[] OPEN_OPTIONS_TRUNCATE = { StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING };
private static final OpenOption[] OPEN_OPTIONS_APPEND = { StandardOpenOption.CREATE, StandardOpenOption.APPEND };
/**
* Empty {@link CopyOption} array.
*
* @since 2.8.0
*/
public static final CopyOption[] EMPTY_COPY_OPTIONS = {};
/**
* Empty {@link DeleteOption} array.
*
* @since 2.8.0
*/
public static final DeleteOption[] EMPTY_DELETE_OPTION_ARRAY = {};
/**
* Empty {@link FileAttribute} array.
*
* @since 2.13.0
*/
public static final FileAttribute[] EMPTY_FILE_ATTRIBUTE_ARRAY = {};
/**
* Empty {@link FileVisitOption} array.
*/
public static final FileVisitOption[] EMPTY_FILE_VISIT_OPTION_ARRAY = {};
/**
* Empty {@link LinkOption} array.
*/
public static final LinkOption[] EMPTY_LINK_OPTION_ARRAY = {};
/**
* {@link LinkOption} array for {@link LinkOption#NOFOLLOW_LINKS}.
*
* @since 2.9.0
* @deprecated Use {@link #noFollowLinkOptionArray()}.
*/
@Deprecated
public static final LinkOption[] NOFOLLOW_LINK_OPTION_ARRAY = { LinkOption.NOFOLLOW_LINKS };
/**
* A LinkOption used to follow link in this class, the inverse of {@link LinkOption#NOFOLLOW_LINKS}.
*
* @since 2.12.0
*/
static final LinkOption NULL_LINK_OPTION = null;
/**
* Empty {@link OpenOption} array.
*/
public static final OpenOption[] EMPTY_OPEN_OPTION_ARRAY = {};
/**
* Empty {@link Path} array.
*
* @since 2.9.0
*/
public static final Path[] EMPTY_PATH_ARRAY = {};
/**
* Accumulates file tree information in a {@link AccumulatorPathVisitor}.
*
* @param directory The directory to accumulate information.
* @param maxDepth See {@link Files#walkFileTree(Path,Set,int,FileVisitor)}.
* @param fileVisitOptions See {@link Files#walkFileTree(Path,Set,int,FileVisitor)}.
* @throws IOException if an I/O error is thrown by a visitor method.
* @return file tree information.
*/
private static AccumulatorPathVisitor accumulate(final Path directory, final int maxDepth, final FileVisitOption[] fileVisitOptions) throws IOException {
return visitFileTree(AccumulatorPathVisitor.withLongCounters(), directory, toFileVisitOptionSet(fileVisitOptions), maxDepth);
}
/**
* Cleans a directory including subdirectories without deleting directories.
*
* @param directory directory to clean.
* @return The visitation path counters.
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static PathCounters cleanDirectory(final Path directory) throws IOException {
return cleanDirectory(directory, EMPTY_DELETE_OPTION_ARRAY);
}
/**
* Cleans a directory including subdirectories without deleting directories.
*
* @param directory directory to clean.
* @param deleteOptions How to handle deletion.
* @return The visitation path counters.
* @throws IOException if an I/O error is thrown by a visitor method.
* @since 2.8.0
*/
public static PathCounters cleanDirectory(final Path directory, final DeleteOption... deleteOptions) throws IOException {
return visitFileTree(new CleaningPathVisitor(Counters.longPathCounters(), deleteOptions), directory).getPathCounters();
}
/**
* Compares the given {@link Path}'s last modified time to the given file time.
*
* @param file the {@link Path} to test.
* @param fileTime the time reference.
* @param options options indicating how to handle symbolic links.
* @return See {@link FileTime#compareTo(FileTime)}
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if the file is {@code null}.
*/
private static int compareLastModifiedTimeTo(final Path file, final FileTime fileTime, final LinkOption... options) throws IOException {
return getLastModifiedTime(file, options).compareTo(fileTime);
}
/**
* Copies the InputStream from the supplier with {@link Files#copy(InputStream, Path, CopyOption...)}.
*
* @param in Supplies the InputStream.
* @param target See {@link Files#copy(InputStream, Path, CopyOption...)}.
* @param copyOptions See {@link Files#copy(InputStream, Path, CopyOption...)}.
* @return See {@link Files#copy(InputStream, Path, CopyOption...)}
* @throws IOException See {@link Files#copy(InputStream, Path, CopyOption...)}
* @since 2.12.0
*/
public static long copy(final IOSupplier in, final Path target, final CopyOption... copyOptions) throws IOException {
try (InputStream inputStream = in.get()) {
return Files.copy(inputStream, target, copyOptions);
}
}
/**
* Copies a directory to another directory.
*
* @param sourceDirectory The source directory.
* @param targetDirectory The target directory.
* @param copyOptions Specifies how the copying should be done.
* @return The visitation path counters.
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static PathCounters copyDirectory(final Path sourceDirectory, final Path targetDirectory, final CopyOption... copyOptions) throws IOException {
final Path absoluteSource = sourceDirectory.toAbsolutePath();
return visitFileTree(new CopyDirectoryVisitor(Counters.longPathCounters(), absoluteSource, targetDirectory, copyOptions), absoluteSource)
.getPathCounters();
}
/**
* Copies a URL to a directory.
*
* @param sourceFile The source URL.
* @param targetFile The target file.
* @param copyOptions Specifies how the copying should be done.
* @return The target file
* @throws IOException if an I/O error occurs.
* @see Files#copy(InputStream, Path, CopyOption...)
*/
public static Path copyFile(final URL sourceFile, final Path targetFile, final CopyOption... copyOptions) throws IOException {
copy(sourceFile::openStream, targetFile, copyOptions);
return targetFile;
}
/**
* Copies a file to a directory.
*
* @param sourceFile The source file.
* @param targetDirectory The target directory.
* @param copyOptions Specifies how the copying should be done.
* @return The target file
* @throws IOException if an I/O error occurs.
* @see Files#copy(Path, Path, CopyOption...)
*/
public static Path copyFileToDirectory(final Path sourceFile, final Path targetDirectory, final CopyOption... copyOptions) throws IOException {
return Files.copy(sourceFile, targetDirectory.resolve(sourceFile.getFileName()), copyOptions);
}
/**
* Copies a URL to a directory.
*
* @param sourceFile The source URL.
* @param targetDirectory The target directory.
* @param copyOptions Specifies how the copying should be done.
* @return The target file
* @throws IOException if an I/O error occurs.
* @see Files#copy(InputStream, Path, CopyOption...)
*/
public static Path copyFileToDirectory(final URL sourceFile, final Path targetDirectory, final CopyOption... copyOptions) throws IOException {
final Path resolve = targetDirectory.resolve(FilenameUtils.getName(sourceFile.getFile()));
copy(sourceFile::openStream, resolve, copyOptions);
return resolve;
}
/**
* Counts aspects of a directory including subdirectories.
*
* @param directory directory to delete.
* @return The visitor used to count the given directory.
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static PathCounters countDirectory(final Path directory) throws IOException {
return visitFileTree(CountingPathVisitor.withLongCounters(), directory).getPathCounters();
}
/**
* Counts aspects of a directory including subdirectories.
*
* @param directory directory to count.
* @return The visitor used to count the given directory.
* @throws IOException if an I/O error occurs.
* @since 2.12.0
*/
public static PathCounters countDirectoryAsBigInteger(final Path directory) throws IOException {
return visitFileTree(CountingPathVisitor.withBigIntegerCounters(), directory).getPathCounters();
}
/**
* Creates the parent directories for the given {@code path}.
*
* If the parent directory already exists, then return it.
*
*
* @param path The path to a file (or directory).
* @param attrs An optional list of file attributes to set atomically when creating the directories.
* @return The Path for the {@code path}'s parent directory or null if the given path has no parent.
* @throws IOException if an I/O error occurs.
* @since 2.9.0
*/
public static Path createParentDirectories(final Path path, final FileAttribute... attrs) throws IOException {
return createParentDirectories(path, LinkOption.NOFOLLOW_LINKS, attrs);
}
/**
* Creates the parent directories for the given {@code path}.
*
* If the parent directory already exists, then return it.
*
*
* @param path The path to a file (or directory).
* @param linkOption A {@link LinkOption} or null.
* @param attrs An optional list of file attributes to set atomically when creating the directories.
* @return The Path for the {@code path}'s parent directory or null if the given path has no parent.
* @throws IOException if an I/O error occurs.
* @since 2.12.0
*/
public static Path createParentDirectories(final Path path, final LinkOption linkOption, final FileAttribute... attrs) throws IOException {
Path parent = getParent(path);
parent = linkOption == LinkOption.NOFOLLOW_LINKS ? parent : readIfSymbolicLink(parent);
if (parent == null) {
return null;
}
final boolean exists = linkOption == null ? Files.exists(parent) : Files.exists(parent, linkOption);
return exists ? parent : Files.createDirectories(parent, attrs);
}
/**
* Gets the current directory.
*
* @return the current directory.
*
* @since 2.9.0
*/
public static Path current() {
return Paths.get(".");
}
/**
* Deletes a file or directory. If the path is a directory, delete it and all subdirectories.
*
* The difference between File.delete() and this method are:
*
*
* - A directory to delete does not have to be empty.
* - You get exceptions when a file or directory cannot be deleted; {@link java.io.File#delete()} returns a boolean.
*
*
* @param path file or directory to delete, must not be {@code null}
* @return The visitor used to delete the given directory.
* @throws NullPointerException if the directory is {@code null}
* @throws IOException if an I/O error is thrown by a visitor method or if an I/O error occurs.
*/
public static PathCounters delete(final Path path) throws IOException {
return delete(path, EMPTY_DELETE_OPTION_ARRAY);
}
/**
* Deletes a file or directory. If the path is a directory, delete it and all subdirectories.
*
* The difference between File.delete() and this method are:
*
*
* - A directory to delete does not have to be empty.
* - You get exceptions when a file or directory cannot be deleted; {@link java.io.File#delete()} returns a boolean.
*
*
* @param path file or directory to delete, must not be {@code null}
* @param deleteOptions How to handle deletion.
* @return The visitor used to delete the given directory.
* @throws NullPointerException if the directory is {@code null}
* @throws IOException if an I/O error is thrown by a visitor method or if an I/O error occurs.
* @since 2.8.0
*/
public static PathCounters delete(final Path path, final DeleteOption... deleteOptions) throws IOException {
// File deletion through Files deletes links, not targets, so use LinkOption.NOFOLLOW_LINKS.
return Files.isDirectory(path, LinkOption.NOFOLLOW_LINKS) ? deleteDirectory(path, deleteOptions) : deleteFile(path, deleteOptions);
}
/**
* Deletes a file or directory. If the path is a directory, delete it and all subdirectories.
*
* The difference between File.delete() and this method are:
*
*
* - A directory to delete does not have to be empty.
* - You get exceptions when a file or directory cannot be deleted; {@link java.io.File#delete()} returns a boolean.
*
*
* @param path file or directory to delete, must not be {@code null}
* @param linkOptions How to handle symbolic links.
* @param deleteOptions How to handle deletion.
* @return The visitor used to delete the given directory.
* @throws NullPointerException if the directory is {@code null}
* @throws IOException if an I/O error is thrown by a visitor method or if an I/O error occurs.
* @since 2.9.0
*/
public static PathCounters delete(final Path path, final LinkOption[] linkOptions, final DeleteOption... deleteOptions) throws IOException {
// File deletion through Files deletes links, not targets, so use LinkOption.NOFOLLOW_LINKS.
return Files.isDirectory(path, linkOptions) ? deleteDirectory(path, linkOptions, deleteOptions) : deleteFile(path, linkOptions, deleteOptions);
}
/**
* Deletes a directory including subdirectories.
*
* @param directory directory to delete.
* @return The visitor used to delete the given directory.
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static PathCounters deleteDirectory(final Path directory) throws IOException {
return deleteDirectory(directory, EMPTY_DELETE_OPTION_ARRAY);
}
/**
* Deletes a directory including subdirectories.
*
* @param directory directory to delete.
* @param deleteOptions How to handle deletion.
* @return The visitor used to delete the given directory.
* @throws IOException if an I/O error is thrown by a visitor method.
* @since 2.8.0
*/
public static PathCounters deleteDirectory(final Path directory, final DeleteOption... deleteOptions) throws IOException {
final LinkOption[] linkOptions = PathUtils.noFollowLinkOptionArray();
// POSIX ops will noop on non-POSIX.
return withPosixFileAttributes(getParent(directory), linkOptions, overrideReadOnly(deleteOptions),
pfa -> visitFileTree(new DeletingPathVisitor(Counters.longPathCounters(), linkOptions, deleteOptions), directory).getPathCounters());
}
/**
* Deletes a directory including subdirectories.
*
* @param directory directory to delete.
* @param linkOptions How to handle symbolic links.
* @param deleteOptions How to handle deletion.
* @return The visitor used to delete the given directory.
* @throws IOException if an I/O error is thrown by a visitor method.
* @since 2.9.0
*/
public static PathCounters deleteDirectory(final Path directory, final LinkOption[] linkOptions, final DeleteOption... deleteOptions) throws IOException {
return visitFileTree(new DeletingPathVisitor(Counters.longPathCounters(), linkOptions, deleteOptions), directory).getPathCounters();
}
/**
* Deletes the given file.
*
* @param file The file to delete.
* @return A visitor with path counts set to 1 file, 0 directories, and the size of the deleted file.
* @throws IOException if an I/O error occurs.
* @throws NoSuchFileException if the file is a directory.
*/
public static PathCounters deleteFile(final Path file) throws IOException {
return deleteFile(file, EMPTY_DELETE_OPTION_ARRAY);
}
/**
* Deletes the given file.
*
* @param file The file to delete.
* @param deleteOptions How to handle deletion.
* @return A visitor with path counts set to 1 file, 0 directories, and the size of the deleted file.
* @throws IOException if an I/O error occurs.
* @throws NoSuchFileException if the file is a directory.
* @since 2.8.0
*/
public static PathCounters deleteFile(final Path file, final DeleteOption... deleteOptions) throws IOException {
// Files.deleteIfExists() never follows links, so use LinkOption.NOFOLLOW_LINKS in other calls to Files.
return deleteFile(file, noFollowLinkOptionArray(), deleteOptions);
}
/**
* Deletes the given file.
*
* @param file The file to delete.
* @param linkOptions How to handle symbolic links.
* @param deleteOptions How to handle deletion.
* @return A visitor with path counts set to 1 file, 0 directories, and the size of the deleted file.
* @throws IOException if an I/O error occurs.
* @throws NoSuchFileException if the file is a directory.
* @since 2.9.0
*/
public static PathCounters deleteFile(final Path file, final LinkOption[] linkOptions, final DeleteOption... deleteOptions)
throws NoSuchFileException, IOException {
//
// TODO Needs clean up
//
if (Files.isDirectory(file, linkOptions)) {
throw new NoSuchFileException(file.toString());
}
final PathCounters pathCounts = Counters.longPathCounters();
boolean exists = exists(file, linkOptions);
long size = exists && !Files.isSymbolicLink(file) ? Files.size(file) : 0;
try {
if (Files.deleteIfExists(file)) {
pathCounts.getFileCounter().increment();
pathCounts.getByteCounter().add(size);
return pathCounts;
}
} catch (final AccessDeniedException ignored) {
// Ignore and try again below.
}
final Path parent = getParent(file);
PosixFileAttributes posixFileAttributes = null;
try {
if (overrideReadOnly(deleteOptions)) {
posixFileAttributes = readPosixFileAttributes(parent, linkOptions);
setReadOnly(file, false, linkOptions);
}
// Read size _after_ having read/execute access on POSIX.
exists = exists(file, linkOptions);
size = exists && !Files.isSymbolicLink(file) ? Files.size(file) : 0;
if (Files.deleteIfExists(file)) {
pathCounts.getFileCounter().increment();
pathCounts.getByteCounter().add(size);
}
} finally {
if (posixFileAttributes != null) {
Files.setPosixFilePermissions(parent, posixFileAttributes.permissions());
}
}
return pathCounts;
}
/**
* Delegates to {@link File#deleteOnExit()}.
*
* @param path the path to delete.
* @since 3.13.0
*/
public static void deleteOnExit(final Path path) {
Objects.requireNonNull(path.toFile()).deleteOnExit();
}
/**
* Compares the file sets of two Paths to determine if they are equal or not while considering file contents. The comparison includes all files in all
* subdirectories.
*
* @param path1 The first directory.
* @param path2 The second directory.
* @return Whether the two directories contain the same files while considering file contents.
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static boolean directoryAndFileContentEquals(final Path path1, final Path path2) throws IOException {
return directoryAndFileContentEquals(path1, path2, EMPTY_LINK_OPTION_ARRAY, EMPTY_OPEN_OPTION_ARRAY, EMPTY_FILE_VISIT_OPTION_ARRAY);
}
/**
* Compares the file sets of two Paths to determine if they are equal or not while considering file contents. The comparison includes all files in all
* subdirectories.
*
* @param path1 The first directory.
* @param path2 The second directory.
* @param linkOptions options to follow links.
* @param openOptions options to open files.
* @param fileVisitOption options to configure traversal.
* @return Whether the two directories contain the same files while considering file contents.
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static boolean directoryAndFileContentEquals(final Path path1, final Path path2, final LinkOption[] linkOptions, final OpenOption[] openOptions,
final FileVisitOption[] fileVisitOption) throws IOException {
// First walk both file trees and gather normalized paths.
if (path1 == null && path2 == null) {
return true;
}
if (path1 == null || path2 == null) {
return false;
}
if (notExists(path1) && notExists(path2)) {
return true;
}
final RelativeSortedPaths relativeSortedPaths = new RelativeSortedPaths(path1, path2, Integer.MAX_VALUE, linkOptions, fileVisitOption);
// If the normalized path names and counts are not the same, no need to compare contents.
if (!relativeSortedPaths.equals) {
return false;
}
// Both visitors contain the same normalized paths, we can compare file contents.
final List fileList1 = relativeSortedPaths.relativeFileList1;
final List fileList2 = relativeSortedPaths.relativeFileList2;
for (final Path path : fileList1) {
final int binarySearch = Collections.binarySearch(fileList2, path);
if (binarySearch <= -1) {
throw new IllegalStateException("Unexpected mismatch.");
}
if (!fileContentEquals(path1.resolve(path), path2.resolve(path), linkOptions, openOptions)) {
return false;
}
}
return true;
}
/**
* Compares the file sets of two Paths to determine if they are equal or not without considering file contents. The comparison includes all files in all
* subdirectories.
*
* @param path1 The first directory.
* @param path2 The second directory.
* @return Whether the two directories contain the same files without considering file contents.
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static boolean directoryContentEquals(final Path path1, final Path path2) throws IOException {
return directoryContentEquals(path1, path2, Integer.MAX_VALUE, EMPTY_LINK_OPTION_ARRAY, EMPTY_FILE_VISIT_OPTION_ARRAY);
}
/**
* Compares the file sets of two Paths to determine if they are equal or not without considering file contents. The comparison includes all files in all
* subdirectories.
*
* @param path1 The first directory.
* @param path2 The second directory.
* @param maxDepth See {@link Files#walkFileTree(Path,Set,int,FileVisitor)}.
* @param linkOptions options to follow links.
* @param fileVisitOptions options to configure the traversal
* @return Whether the two directories contain the same files without considering file contents.
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static boolean directoryContentEquals(final Path path1, final Path path2, final int maxDepth, final LinkOption[] linkOptions,
final FileVisitOption[] fileVisitOptions) throws IOException {
return new RelativeSortedPaths(path1, path2, maxDepth, linkOptions, fileVisitOptions).equals;
}
private static boolean exists(final Path path, final LinkOption... options) {
Objects.requireNonNull(path, "path");
return options != null ? Files.exists(path, options) : Files.exists(path);
}
/**
* Compares the file contents of two Paths to determine if they are equal or not.
*
* File content is accessed through {@link Files#newInputStream(Path,OpenOption...)}.
*
*
* @param path1 the first stream.
* @param path2 the second stream.
* @return true if the content of the streams are equal or they both don't exist, false otherwise.
* @throws NullPointerException if either input is null.
* @throws IOException if an I/O error occurs.
* @see org.apache.commons.io.FileUtils#contentEquals(java.io.File, java.io.File)
*/
public static boolean fileContentEquals(final Path path1, final Path path2) throws IOException {
return fileContentEquals(path1, path2, EMPTY_LINK_OPTION_ARRAY, EMPTY_OPEN_OPTION_ARRAY);
}
/**
* Compares the file contents of two Paths to determine if they are equal or not.
*
* File content is accessed through {@link RandomAccessFileMode#create(Path)}.
*
*
* @param path1 the first stream.
* @param path2 the second stream.
* @param linkOptions options specifying how files are followed.
* @param openOptions ignored.
* @return true if the content of the streams are equal or they both don't exist, false otherwise.
* @throws NullPointerException if openOptions is null.
* @throws IOException if an I/O error occurs.
* @see org.apache.commons.io.FileUtils#contentEquals(java.io.File, java.io.File)
*/
public static boolean fileContentEquals(final Path path1, final Path path2, final LinkOption[] linkOptions, final OpenOption[] openOptions)
throws IOException {
if (path1 == null && path2 == null) {
return true;
}
if (path1 == null || path2 == null) {
return false;
}
final Path nPath1 = path1.normalize();
final Path nPath2 = path2.normalize();
final boolean path1Exists = exists(nPath1, linkOptions);
if (path1Exists != exists(nPath2, linkOptions)) {
return false;
}
if (!path1Exists) {
// Two not existing files are equal?
// Same as FileUtils
return true;
}
if (Files.isDirectory(nPath1, linkOptions)) {
// don't compare directory contents.
throw new IOException("Can't compare directories, only files: " + nPath1);
}
if (Files.isDirectory(nPath2, linkOptions)) {
// don't compare directory contents.
throw new IOException("Can't compare directories, only files: " + nPath2);
}
if (Files.size(nPath1) != Files.size(nPath2)) {
// lengths differ, cannot be equal
return false;
}
if (path1.equals(path2)) {
// same file
return true;
}
// Faster:
try (RandomAccessFile raf1 = RandomAccessFileMode.READ_ONLY.create(path1.toRealPath(linkOptions));
RandomAccessFile raf2 = RandomAccessFileMode.READ_ONLY.create(path2.toRealPath(linkOptions))) {
return RandomAccessFiles.contentEquals(raf1, raf2);
} catch (final UnsupportedOperationException e) {
// Slower:
// Handle
// java.lang.UnsupportedOperationException
// at com.sun.nio.zipfs.ZipPath.toFile(ZipPath.java:656)
try (InputStream inputStream1 = Files.newInputStream(nPath1, openOptions);
InputStream inputStream2 = Files.newInputStream(nPath2, openOptions)) {
return IOUtils.contentEquals(inputStream1, inputStream2);
}
}
}
/**
*
* Applies an {@link IOFileFilter} to the provided {@link File} objects. The resulting array is a subset of the original file list that matches the provided
* filter.
*
*
*
* The {@link Set} returned by this method is not guaranteed to be thread safe.
*
*
*
* Set<File> allFiles = ...
* Set<File> javaFiles = FileFilterUtils.filterSet(allFiles,
* FileFilterUtils.suffixFileFilter(".java"));
*
*
* @param filter the filter to apply to the set of files.
* @param paths the array of files to apply the filter to.
*
* @return a subset of {@code files} that is accepted by the file filter.
* @throws NullPointerException if the filter is {@code null}
* @throws IllegalArgumentException if {@code files} contains a {@code null} value.
*
* @since 2.9.0
*/
public static Path[] filter(final PathFilter filter, final Path... paths) {
Objects.requireNonNull(filter, "filter");
if (paths == null) {
return EMPTY_PATH_ARRAY;
}
return filterPaths(filter, Stream.of(paths), Collectors.toList()).toArray(EMPTY_PATH_ARRAY);
}
private static R filterPaths(final PathFilter filter, final Stream stream, final Collector collector) {
Objects.requireNonNull(filter, "filter");
Objects.requireNonNull(collector, "collector");
if (stream == null) {
return Stream.empty().collect(collector);
}
return stream.filter(p -> {
try {
return p != null && filter.accept(p, readBasicFileAttributes(p)) == FileVisitResult.CONTINUE;
} catch (final IOException e) {
return false;
}
}).collect(collector);
}
/**
* Reads the access control list from a file attribute view.
*
* @param sourcePath the path to the file.
* @return a file attribute view of the given type, or null if the attribute view type is not available.
* @throws IOException if an I/O error occurs.
* @since 2.8.0
*/
public static List getAclEntryList(final Path sourcePath) throws IOException {
final AclFileAttributeView fileAttributeView = getAclFileAttributeView(sourcePath);
return fileAttributeView == null ? null : fileAttributeView.getAcl();
}
/**
* Shorthand for {@code Files.getFileAttributeView(path, AclFileAttributeView.class)}.
*
* @param path the path to the file.
* @param options how to handle symbolic links.
* @return a AclFileAttributeView, or {@code null} if the attribute view type is not available.
* @since 2.12.0
*/
public static AclFileAttributeView getAclFileAttributeView(final Path path, final LinkOption... options) {
return Files.getFileAttributeView(path, AclFileAttributeView.class, options);
}
/**
* Gets the base name (the part up to and not including the last ".") of the last path segment of a file name.
*
* Will return the file name itself if it doesn't contain any dots. All leading directories of the {@code file name} parameter are skipped.
*
*
* @return the base name of file name
* @param path the path of the file to obtain the base name of.
* @since 2.16.0
*/
public static String getBaseName(final Path path) {
if (path == null) {
return null;
}
final Path fileName = path.getFileName();
return fileName != null ? FilenameUtils.removeExtension(fileName.toString()) : null;
}
/**
* Shorthand for {@code Files.getFileAttributeView(path, DosFileAttributeView.class)}.
*
* @param path the path to the file.
* @param options how to handle symbolic links.
* @return a DosFileAttributeView, or {@code null} if the attribute view type is not available.
* @since 2.12.0
*/
public static DosFileAttributeView getDosFileAttributeView(final Path path, final LinkOption... options) {
return Files.getFileAttributeView(path, DosFileAttributeView.class, options);
}
/**
* Gets the extension of a Path.
*
* This method returns the textual part of the Path after the last dot.
*
*
* foo.txt --> "txt"
* a/b/c.jpg --> "jpg"
* a/b.txt/c --> ""
* a/b/c --> ""
*
*
* The output will be the same irrespective of the machine that the code is running on.
*
*
* @param path the path to query.
* @return the extension of the file or an empty string if none exists or {@code null} if the fileName is {@code null}.
* @since 2.16.0
*/
public static String getExtension(final Path path) {
final String fileName = getFileNameString(path);
return fileName != null ? FilenameUtils.getExtension(fileName) : null;
}
/**
* Gets the Path's file name and apply the given function if the file name is non-null.
*
* @param The function's result type.
* @param path the path to query.
* @param function function to apply to the file name.
* @return the Path's file name as a string or null.
* @see Path#getFileName()
* @since 2.16.0
*/
public static R getFileName(final Path path, final Function function) {
final Path fileName = path != null ? path.getFileName() : null;
return fileName != null ? function.apply(fileName) : null;
}
/**
* Gets the Path's file name as a string.
*
* @param path the path to query.
* @return the Path's file name as a string or null.
* @see Path#getFileName()
* @since 2.16.0
*/
public static String getFileNameString(final Path path) {
return getFileName(path, Path::toString);
}
/**
* Gets the file's last modified time or null if the file does not exist.
*
* The method provides a workaround for bug JDK-8177809 where {@link File#lastModified()}
* looses milliseconds and always ends in 000. This bug is in OpenJDK 8 and 9, and fixed in 11.
*
*
* @param file the file to query.
* @return the file's last modified time.
* @throws IOException Thrown if an I/O error occurs.
* @since 2.12.0
*/
public static FileTime getLastModifiedFileTime(final File file) throws IOException {
return getLastModifiedFileTime(file.toPath(), null, EMPTY_LINK_OPTION_ARRAY);
}
/**
* Gets the file's last modified time or null if the file does not exist.
*
* @param path the file to query.
* @param defaultIfAbsent Returns this file time of the file does not exist, may be null.
* @param options options indicating how symbolic links are handled.
* @return the file's last modified time.
* @throws IOException Thrown if an I/O error occurs.
* @since 2.12.0
*/
public static FileTime getLastModifiedFileTime(final Path path, final FileTime defaultIfAbsent, final LinkOption... options) throws IOException {
return Files.exists(path) ? getLastModifiedTime(path, options) : defaultIfAbsent;
}
/**
* Gets the file's last modified time or null if the file does not exist.
*
* @param path the file to query.
* @param options options indicating how symbolic links are handled.
* @return the file's last modified time.
* @throws IOException Thrown if an I/O error occurs.
* @since 2.12.0
*/
public static FileTime getLastModifiedFileTime(final Path path, final LinkOption... options) throws IOException {
return getLastModifiedFileTime(path, null, options);
}
/**
* Gets the file's last modified time or null if the file does not exist.
*
* @param uri the file to query.
* @return the file's last modified time.
* @throws IOException Thrown if an I/O error occurs.
* @since 2.12.0
*/
public static FileTime getLastModifiedFileTime(final URI uri) throws IOException {
return getLastModifiedFileTime(Paths.get(uri), null, EMPTY_LINK_OPTION_ARRAY);
}
/**
* Gets the file's last modified time or null if the file does not exist.
*
* @param url the file to query.
* @return the file's last modified time.
* @throws IOException Thrown if an I/O error occurs.
* @throws URISyntaxException if the URL is not formatted strictly according to RFC2396 and cannot be converted to a URI.
* @since 2.12.0
*/
public static FileTime getLastModifiedFileTime(final URL url) throws IOException, URISyntaxException {
return getLastModifiedFileTime(url.toURI());
}
private static FileTime getLastModifiedTime(final Path path, final LinkOption... options) throws IOException {
return Files.getLastModifiedTime(Objects.requireNonNull(path, "path"), options);
}
private static Path getParent(final Path path) {
return path == null ? null : path.getParent();
}
/**
* Shorthand for {@code Files.getFileAttributeView(path, PosixFileAttributeView.class)}.
*
* @param path the path to the file.
* @param options how to handle symbolic links.
* @return a PosixFileAttributeView, or {@code null} if the attribute view type is not available.
* @since 2.12.0
*/
public static PosixFileAttributeView getPosixFileAttributeView(final Path path, final LinkOption... options) {
return Files.getFileAttributeView(path, PosixFileAttributeView.class, options);
}
/**
* Gets a {@link Path} representing the system temporary directory.
*
* @return the system temporary directory.
* @since 2.12.0
*/
public static Path getTempDirectory() {
return Paths.get(FileUtils.getTempDirectoryPath());
}
/**
* Tests whether the given {@link Path} is a directory or not. Implemented as a null-safe delegate to
* {@code Files.isDirectory(Path path, LinkOption... options)}.
*
* @param path the path to the file.
* @param options options indicating how to handle symbolic links
* @return {@code true} if the file is a directory; {@code false} if the path is null, the file does not exist, is not a directory, or it cannot be
* determined if the file is a directory or not.
* @throws SecurityException In the case of the default provider, and a security manager is installed, the {@link SecurityManager#checkRead(String)
* checkRead} method is invoked to check read access to the directory.
* @since 2.9.0
*/
public static boolean isDirectory(final Path path, final LinkOption... options) {
return path != null && Files.isDirectory(path, options);
}
/**
* Tests whether the given file or directory is empty.
*
* @param path the file or directory to query.
* @return whether the file or directory is empty.
* @throws IOException if an I/O error occurs.
*/
public static boolean isEmpty(final Path path) throws IOException {
return Files.isDirectory(path) ? isEmptyDirectory(path) : isEmptyFile(path);
}
/**
* Tests whether the directory is empty.
*
* @param directory the directory to query.
* @return whether the directory is empty.
* @throws NotDirectoryException if the file could not otherwise be opened because it is not a directory (optional specific exception).
* @throws IOException if an I/O error occurs.
* @throws SecurityException In the case of the default provider, and a security manager is installed, the {@link SecurityManager#checkRead(String)
* checkRead} method is invoked to check read access to the directory.
*/
public static boolean isEmptyDirectory(final Path directory) throws IOException {
try (DirectoryStream directoryStream = Files.newDirectoryStream(directory)) {
return !directoryStream.iterator().hasNext();
}
}
/**
* Tests whether the given file is empty.
*
* @param file the file to query.
* @return whether the file is empty.
* @throws IOException if an I/O error occurs.
* @throws SecurityException In the case of the default provider, and a security manager is installed, its {@link SecurityManager#checkRead(String)
* checkRead} method denies read access to the file.
*/
public static boolean isEmptyFile(final Path file) throws IOException {
return Files.size(file) <= 0;
}
/**
* Tests if the given {@link Path} is newer than the given time reference.
*
* @param file the {@link Path} to test.
* @param czdt the time reference.
* @param options options indicating how to handle symbolic links.
* @return true if the {@link Path} exists and has been modified after the given time reference.
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if the file is {@code null}.
* @since 2.12.0
*/
public static boolean isNewer(final Path file, final ChronoZonedDateTime czdt, final LinkOption... options) throws IOException {
Objects.requireNonNull(czdt, "czdt");
return isNewer(file, czdt.toInstant(), options);
}
/**
* Tests if the given {@link Path} is newer than the given time reference.
*
* @param file the {@link Path} to test.
* @param fileTime the time reference.
* @param options options indicating how to handle symbolic links.
* @return true if the {@link Path} exists and has been modified after the given time reference.
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if the file is {@code null}.
* @since 2.12.0
*/
public static boolean isNewer(final Path file, final FileTime fileTime, final LinkOption... options) throws IOException {
if (notExists(file)) {
return false;
}
return compareLastModifiedTimeTo(file, fileTime, options) > 0;
}
/**
* Tests if the given {@link Path} is newer than the given time reference.
*
* @param file the {@link Path} to test.
* @param instant the time reference.
* @param options options indicating how to handle symbolic links.
* @return true if the {@link Path} exists and has been modified after the given time reference.
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if the file is {@code null}.
* @since 2.12.0
*/
public static boolean isNewer(final Path file, final Instant instant, final LinkOption... options) throws IOException {
return isNewer(file, FileTime.from(instant), options);
}
/**
* Tests if the given {@link Path} is newer than the given time reference.
*
* @param file the {@link Path} to test.
* @param timeMillis the time reference measured in milliseconds since the epoch (00:00:00 GMT, January 1, 1970)
* @param options options indicating how to handle symbolic links.
* @return true if the {@link Path} exists and has been modified after the given time reference.
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if the file is {@code null}.
* @since 2.9.0
*/
public static boolean isNewer(final Path file, final long timeMillis, final LinkOption... options) throws IOException {
return isNewer(file, FileTime.fromMillis(timeMillis), options);
}
/**
* Tests if the given {@link Path} is newer than the reference {@link Path}.
*
* @param file the {@link File} to test.
* @param reference the {@link File} of which the modification date is used.
* @return true if the {@link File} exists and has been modified more recently than the reference {@link File}.
* @throws IOException if an I/O error occurs.
* @since 2.12.0
*/
public static boolean isNewer(final Path file, final Path reference) throws IOException {
return isNewer(file, getLastModifiedTime(reference));
}
/**
* Tests if the given {@link Path} is older than the given time reference.
*
* @param file the {@link Path} to test.
* @param fileTime the time reference.
* @param options options indicating how to handle symbolic links.
* @return true if the {@link Path} exists and has been modified before the given time reference.
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if the file is {@code null}.
* @since 2.12.0
*/
public static boolean isOlder(final Path file, final FileTime fileTime, final LinkOption... options) throws IOException {
if (notExists(file)) {
return false;
}
return compareLastModifiedTimeTo(file, fileTime, options) < 0;
}
/**
* Tests if the given {@link Path} is older than the given time reference.
*
* @param file the {@link Path} to test.
* @param instant the time reference.
* @param options options indicating how to handle symbolic links.
* @return true if the {@link Path} exists and has been modified before the given time reference.
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if the file is {@code null}.
* @since 2.12.0
*/
public static boolean isOlder(final Path file, final Instant instant, final LinkOption... options) throws IOException {
return isOlder(file, FileTime.from(instant), options);
}
/**
* Tests if the given {@link Path} is older than the given time reference.
*
* @param file the {@link Path} to test.
* @param timeMillis the time reference measured in milliseconds since the epoch (00:00:00 GMT, January 1, 1970)
* @param options options indicating how to handle symbolic links.
* @return true if the {@link Path} exists and has been modified before the given time reference.
* @throws IOException if an I/O error occurs.
* @throws NullPointerException if the file is {@code null}.
* @since 2.12.0
*/
public static boolean isOlder(final Path file, final long timeMillis, final LinkOption... options) throws IOException {
return isOlder(file, FileTime.fromMillis(timeMillis), options);
}
/**
* Tests if the given {@link Path} is older than the reference {@link Path}.
*
* @param file the {@link File} to test.
* @param reference the {@link File} of which the modification date is used.
* @return true if the {@link File} exists and has been modified before than the reference {@link File}.
* @throws IOException if an I/O error occurs.
* @since 2.12.0
*/
public static boolean isOlder(final Path file, final Path reference) throws IOException {
return isOlder(file, getLastModifiedTime(reference));
}
/**
* Tests whether the given path is on a POSIX file system.
*
* @param test The Path to test.
* @param options options indicating how to handle symbolic links.
* @return true if test is on a POSIX file system.
* @since 2.12.0
*/
public static boolean isPosix(final Path test, final LinkOption... options) {
return exists(test, options) && readPosixFileAttributes(test, options) != null;
}
/**
* Tests whether the given {@link Path} is a regular file or not. Implemented as a null-safe delegate to
* {@code Files.isRegularFile(Path path, LinkOption... options)}.
*
* @param path the path to the file.
* @param options options indicating how to handle symbolic links.
* @return {@code true} if the file is a regular file; {@code false} if the path is null, the file does not exist, is not a directory, or it cannot be
* determined if the file is a regular file or not.
* @throws SecurityException In the case of the default provider, and a security manager is installed, the {@link SecurityManager#checkRead(String)
* checkRead} method is invoked to check read access to the directory.
* @since 2.9.0
*/
public static boolean isRegularFile(final Path path, final LinkOption... options) {
return path != null && Files.isRegularFile(path, options);
}
/**
* Creates a new DirectoryStream for Paths rooted at the given directory.
*
* If you don't use the try-with-resources construct, then you must call the stream's {@link Stream#close()} method after iteration is complete to free any
* resources held for the open directory.
*
*
* @param dir the path to the directory to stream.
* @param pathFilter the directory stream filter.
* @return a new instance.
* @throws IOException if an I/O error occurs.
*/
public static DirectoryStream newDirectoryStream(final Path dir, final PathFilter pathFilter) throws IOException {
return Files.newDirectoryStream(dir, new DirectoryStreamFilter(pathFilter));
}
/**
* Creates a new OutputStream by opening or creating a file, returning an output stream that may be used to write bytes to the file.
*
* @param path the Path.
* @param append Whether or not to append.
* @return a new OutputStream.
* @throws IOException if an I/O error occurs.
* @see Files#newOutputStream(Path, OpenOption...)
* @since 2.12.0
*/
public static OutputStream newOutputStream(final Path path, final boolean append) throws IOException {
return newOutputStream(path, EMPTY_LINK_OPTION_ARRAY, append ? OPEN_OPTIONS_APPEND : OPEN_OPTIONS_TRUNCATE);
}
static OutputStream newOutputStream(final Path path, final LinkOption[] linkOptions, final OpenOption... openOptions) throws IOException {
if (!exists(path, linkOptions)) {
createParentDirectories(path, linkOptions != null && linkOptions.length > 0 ? linkOptions[0] : NULL_LINK_OPTION);
}
final List list = new ArrayList<>(Arrays.asList(openOptions != null ? openOptions : EMPTY_OPEN_OPTION_ARRAY));
list.addAll(Arrays.asList(linkOptions != null ? linkOptions : EMPTY_LINK_OPTION_ARRAY));
return Files.newOutputStream(path, list.toArray(EMPTY_OPEN_OPTION_ARRAY));
}
/**
* Copy of the {@link LinkOption} array for {@link LinkOption#NOFOLLOW_LINKS}.
*
* @return Copy of the {@link LinkOption} array for {@link LinkOption#NOFOLLOW_LINKS}.
*/
public static LinkOption[] noFollowLinkOptionArray() {
return NOFOLLOW_LINK_OPTION_ARRAY.clone();
}
private static boolean notExists(final Path path, final LinkOption... options) {
return Files.notExists(Objects.requireNonNull(path, "path"), options);
}
/**
* Returns true if the given options contain {@link StandardDeleteOption#OVERRIDE_READ_ONLY}.
*
* @param deleteOptions the array to test
* @return true if the given options contain {@link StandardDeleteOption#OVERRIDE_READ_ONLY}.
*/
private static boolean overrideReadOnly(final DeleteOption... deleteOptions) {
if (deleteOptions == null) {
return false;
}
return Stream.of(deleteOptions).anyMatch(e -> e == StandardDeleteOption.OVERRIDE_READ_ONLY);
}
/**
* Reads the BasicFileAttributes from the given path. Returns null if the attributes can't be read.
*
* @param The {@link BasicFileAttributes} type
* @param path The Path to test.
* @param type the {@link Class} of the file attributes required to read.
* @param options options indicating how to handle symbolic links.
* @return the file attributes or null if the attributes can't be read.
* @see Files#readAttributes(Path, Class, LinkOption...)
* @since 2.12.0
*/
public static A readAttributes(final Path path, final Class type, final LinkOption... options) {
try {
return path == null ? null : Files.readAttributes(path, type, options);
} catch (final UnsupportedOperationException | IOException e) {
// For example, on Windows.
return null;
}
}
/**
* Reads the BasicFileAttributes from the given path.
*
* @param path the path to read.
* @return the path attributes.
* @throws IOException if an I/O error occurs.
* @since 2.9.0
*/
public static BasicFileAttributes readBasicFileAttributes(final Path path) throws IOException {
return Files.readAttributes(path, BasicFileAttributes.class);
}
/**
* Reads the BasicFileAttributes from the given path. Returns null if the attributes can't be read.
*
* @param path the path to read.
* @param options options indicating how to handle symbolic links.
* @return the path attributes.
* @since 2.12.0
*/
public static BasicFileAttributes readBasicFileAttributes(final Path path, final LinkOption... options) {
return readAttributes(path, BasicFileAttributes.class, options);
}
/**
* Reads the BasicFileAttributes from the given path. Returns null if the attributes can't be read.
*
* @param path the path to read.
* @return the path attributes.
* @since 2.9.0
* @deprecated Use {@link #readBasicFileAttributes(Path, LinkOption...)}.
*/
@Deprecated
public static BasicFileAttributes readBasicFileAttributesUnchecked(final Path path) {
return readBasicFileAttributes(path, EMPTY_LINK_OPTION_ARRAY);
}
/**
* Reads the DosFileAttributes from the given path. Returns null if the attributes can't be read.
*
* @param path the path to read.
* @param options options indicating how to handle symbolic links.
* @return the path attributes.
* @since 2.12.0
*/
public static DosFileAttributes readDosFileAttributes(final Path path, final LinkOption... options) {
return readAttributes(path, DosFileAttributes.class, options);
}
private static Path readIfSymbolicLink(final Path path) throws IOException {
return path != null ? Files.isSymbolicLink(path) ? Files.readSymbolicLink(path) : path : null;
}
/**
* Reads the PosixFileAttributes or DosFileAttributes from the given path. Returns null if the attributes can't be read.
*
* @param path The Path to read.
* @param options options indicating how to handle symbolic links.
* @return the file attributes.
* @since 2.12.0
*/
public static BasicFileAttributes readOsFileAttributes(final Path path, final LinkOption... options) {
final PosixFileAttributes fileAttributes = readPosixFileAttributes(path, options);
return fileAttributes != null ? fileAttributes : readDosFileAttributes(path, options);
}
/**
* Reads the PosixFileAttributes from the given path. Returns null instead of throwing {@link UnsupportedOperationException}.
*
* @param path The Path to read.
* @param options options indicating how to handle symbolic links.
* @return the file attributes.
* @since 2.12.0
*/
public static PosixFileAttributes readPosixFileAttributes(final Path path, final LinkOption... options) {
return readAttributes(path, PosixFileAttributes.class, options);
}
/**
* Reads the given path as a String.
*
* @param path The source path.
* @param charset How to convert bytes to a String, null uses the default Charset.
* @return a new String.
* @throws IOException if an I/O error occurs reading from the stream.
* @see Files#readAllBytes(Path)
* @since 2.12.0
*/
public static String readString(final Path path, final Charset charset) throws IOException {
return new String(Files.readAllBytes(path), Charsets.toCharset(charset));
}
/**
* Relativizes all files in the given {@code collection} against a {@code parent}.
*
* @param collection The collection of paths to relativize.
* @param parent relativizes against this parent path.
* @param sort Whether to sort the result.
* @param comparator How to sort.
* @return A collection of relativized paths, optionally sorted.
*/
static List relativize(final Collection collection, final Path parent, final boolean sort, final Comparator comparator) {
Stream stream = collection.stream().map(parent::relativize);
if (sort) {
stream = comparator == null ? stream.sorted() : stream.sorted(comparator);
}
return stream.collect(Collectors.toList());
}
/**
* Requires that the given {@link File} exists and throws an {@link IllegalArgumentException} if it doesn't.
*
* @param file The {@link File} to check.
* @param fileParamName The parameter name to use in the exception message in case of {@code null} input.
* @param options options indicating how to handle symbolic links.
* @return the given file.
* @throws NullPointerException if the given {@link File} is {@code null}.
* @throws IllegalArgumentException if the given {@link File} does not exist.
*/
private static Path requireExists(final Path file, final String fileParamName, final LinkOption... options) {
Objects.requireNonNull(file, fileParamName);
if (!exists(file, options)) {
throw new IllegalArgumentException("File system element for parameter '" + fileParamName + "' does not exist: '" + file + "'");
}
return file;
}
private static boolean setDosReadOnly(final Path path, final boolean readOnly, final LinkOption... linkOptions) throws IOException {
final DosFileAttributeView dosFileAttributeView = getDosFileAttributeView(path, linkOptions);
if (dosFileAttributeView != null) {
dosFileAttributeView.setReadOnly(readOnly);
return true;
}
return false;
}
/**
* Sets the given {@code targetFile}'s last modified time to the value from {@code sourceFile}.
*
* @param sourceFile The source path to query.
* @param targetFile The target path to set.
* @throws NullPointerException if sourceFile is {@code null}.
* @throws NullPointerException if targetFile is {@code null}.
* @throws IOException if setting the last-modified time failed.
* @since 2.12.0
*/
public static void setLastModifiedTime(final Path sourceFile, final Path targetFile) throws IOException {
Objects.requireNonNull(sourceFile, "sourceFile");
Files.setLastModifiedTime(targetFile, getLastModifiedTime(sourceFile));
}
/**
* To delete a file in POSIX, you need Write and Execute permissions on its parent directory.
*
* @param parent The parent path for a file element to delete which needs RW permissions.
* @param enableDeleteChildren true to set permissions to delete.
* @param linkOptions options indicating how handle symbolic links.
* @return true if the operation was attempted and succeeded, false if parent is null.
* @throws IOException if an I/O error occurs.
*/
private static boolean setPosixDeletePermissions(final Path parent, final boolean enableDeleteChildren, final LinkOption... linkOptions)
throws IOException {
// To delete a file in POSIX, you need write and execute permissions on its parent directory.
// @formatter:off
return setPosixPermissions(parent, enableDeleteChildren, Arrays.asList(
PosixFilePermission.OWNER_WRITE,
//PosixFilePermission.GROUP_WRITE,
//PosixFilePermission.OTHERS_WRITE,
PosixFilePermission.OWNER_EXECUTE
//PosixFilePermission.GROUP_EXECUTE,
//PosixFilePermission.OTHERS_EXECUTE
), linkOptions);
// @formatter:on
}
/**
* Low-level POSIX permission operation to set permissions.
*
* If the permissions to update are already set, then make no additional calls.
*
*
* @param path Set this path's permissions.
* @param addPermissions true to add, false to remove.
* @param updatePermissions the List of PosixFilePermission to add or remove.
* @param linkOptions options indicating how handle symbolic links.
* @return true if the operation was attempted and succeeded, false if parent is null.
* @throws IOException if an I/O error occurs.
*/
private static boolean setPosixPermissions(final Path path, final boolean addPermissions, final List updatePermissions,
final LinkOption... linkOptions) throws IOException {
if (path != null) {
final Set permissions = Files.getPosixFilePermissions(path, linkOptions);
final Set newPermissions = new HashSet<>(permissions);
if (addPermissions) {
newPermissions.addAll(updatePermissions);
} else {
newPermissions.removeAll(updatePermissions);
}
if (!newPermissions.equals(permissions)) {
Files.setPosixFilePermissions(path, newPermissions);
}
return true;
}
return false;
}
private static void setPosixReadOnlyFile(final Path path, final boolean readOnly, final LinkOption... linkOptions) throws IOException {
// Not Windows 10
final Set permissions = Files.getPosixFilePermissions(path, linkOptions);
// @formatter:off
final List readPermissions = Arrays.asList(
PosixFilePermission.OWNER_READ
//PosixFilePermission.GROUP_READ,
//PosixFilePermission.OTHERS_READ
);
final List writePermissions = Arrays.asList(
PosixFilePermission.OWNER_WRITE
//PosixFilePermission.GROUP_WRITE,
//PosixFilePermission.OTHERS_WRITE
);
// @formatter:on
if (readOnly) {
// RO: We can read, we cannot write.
permissions.addAll(readPermissions);
permissions.removeAll(writePermissions);
} else {
// Not RO: We can read, we can write.
permissions.addAll(readPermissions);
permissions.addAll(writePermissions);
}
Files.setPosixFilePermissions(path, permissions);
}
/**
* Sets the given Path to the {@code readOnly} value.
*
* This behavior is OS dependent.
*
*
* @param path The path to set.
* @param readOnly true for read-only, false for not read-only.
* @param linkOptions options indicating how to handle symbolic links.
* @return The given path.
* @throws IOException if an I/O error occurs.
* @since 2.8.0
*/
public static Path setReadOnly(final Path path, final boolean readOnly, final LinkOption... linkOptions) throws IOException {
try {
// Windows is simplest
if (setDosReadOnly(path, readOnly, linkOptions)) {
return path;
}
} catch (final IOException ignored) {
// Retry with POSIX below.
}
final Path parent = getParent(path);
if (!isPosix(parent, linkOptions)) { // Test parent because we may not the permissions to test the file.
throw new IOException(String.format("DOS or POSIX file operations not available for '%s' %s", path, Arrays.toString(linkOptions)));
}
// POSIX
if (readOnly) {
// RO
// File, then parent dir (if any).
setPosixReadOnlyFile(path, readOnly, linkOptions);
setPosixDeletePermissions(parent, false, linkOptions);
} else {
// RE
// Parent dir (if any), then file.
setPosixDeletePermissions(parent, true, linkOptions);
}
return path;
}
/**
* Returns the size of the given file or directory. If the provided {@link Path} is a regular file, then the file's size is returned. If the argument is a
* directory, then the size of the directory is calculated recursively.
*
* Note that overflow is not detected, and the return value may be negative if overflow occurs. See {@link #sizeOfAsBigInteger(Path)} for an alternative
* method that does not overflow.
*
*
* @param path the regular file or directory to return the size of, must not be {@code null}.
* @return the length of the file, or recursive size of the directory, in bytes.
* @throws NullPointerException if the file is {@code null}.
* @throws IllegalArgumentException if the file does not exist.
* @throws IOException if an I/O error occurs.
* @since 2.12.0
*/
public static long sizeOf(final Path path) throws IOException {
requireExists(path, "path");
return Files.isDirectory(path) ? sizeOfDirectory(path) : Files.size(path);
}
/**
* Returns the size of the given file or directory. If the provided {@link Path} is a regular file, then the file's size is returned. If the argument is a
* directory, then the size of the directory is calculated recursively.
*
* @param path the regular file or directory to return the size of (must not be {@code null}).
* @return the length of the file, or recursive size of the directory, provided (in bytes).
* @throws NullPointerException if the file is {@code null}.
* @throws IllegalArgumentException if the file does not exist.
* @throws IOException if an I/O error occurs.
* @since 2.12.0
*/
public static BigInteger sizeOfAsBigInteger(final Path path) throws IOException {
requireExists(path, "path");
return Files.isDirectory(path) ? sizeOfDirectoryAsBigInteger(path) : BigInteger.valueOf(Files.size(path));
}
/**
* Counts the size of a directory recursively (sum of the size of all files).
*
* Note that overflow is not detected, and the return value may be negative if overflow occurs. See {@link #sizeOfDirectoryAsBigInteger(Path)} for an
* alternative method that does not overflow.
*
*
* @param directory directory to inspect, must not be {@code null}.
* @return size of directory in bytes, 0 if directory is security restricted, a negative number when the real total is greater than {@link Long#MAX_VALUE}.
* @throws NullPointerException if the directory is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 2.12.0
*/
public static long sizeOfDirectory(final Path directory) throws IOException {
return countDirectory(directory).getByteCounter().getLong();
}
/**
* Counts the size of a directory recursively (sum of the size of all files).
*
* @param directory directory to inspect, must not be {@code null}.
* @return size of directory in bytes, 0 if directory is security restricted.
* @throws NullPointerException if the directory is {@code null}.
* @throws IOException if an I/O error occurs.
* @since 2.12.0
*/
public static BigInteger sizeOfDirectoryAsBigInteger(final Path directory) throws IOException {
return countDirectoryAsBigInteger(directory).getByteCounter().getBigInteger();
}
/**
* Converts an array of {@link FileVisitOption} to a {@link Set}.
*
* @param fileVisitOptions input array.
* @return a new Set.
*/
static Set toFileVisitOptionSet(final FileVisitOption... fileVisitOptions) {
return fileVisitOptions == null ? EnumSet.noneOf(FileVisitOption.class) : Stream.of(fileVisitOptions).collect(Collectors.toSet());
}
/**
* Implements behavior similar to the UNIX "touch" utility. Creates a new file with size 0, or, if the file exists, just updates the file's modified time.
* this method creates parent directories if they do not exist.
*
* @param file the file to touch.
* @return The given file.
* @throws NullPointerException if the parameter is {@code null}.
* @throws IOException if setting the last-modified time failed or an I/O problem occurs.\
* @since 2.12.0
*/
public static Path touch(final Path file) throws IOException {
Objects.requireNonNull(file, "file");
if (!Files.exists(file)) {
createParentDirectories(file);
Files.createFile(file);
} else {
FileTimes.setLastModifiedTime(file);
}
return file;
}
/**
* Performs {@link Files#walkFileTree(Path,FileVisitor)} and returns the given visitor.
*
* Note that {@link Files#walkFileTree(Path,FileVisitor)} returns the given path.
*
* @param visitor See {@link Files#walkFileTree(Path,FileVisitor)}.
* @param directory See {@link Files#walkFileTree(Path,FileVisitor)}.
* @param See {@link Files#walkFileTree(Path,FileVisitor)}.
* @return the given visitor.
*
* @throws NoSuchFileException if the directory does not exist.
* @throws IOException if an I/O error is thrown by a visitor method.
* @throws NullPointerException if the directory is {@code null}.
*/
public static > T visitFileTree(final T visitor, final Path directory) throws IOException {
Files.walkFileTree(directory, visitor);
return visitor;
}
/**
* Performs {@link Files#walkFileTree(Path,FileVisitor)} and returns the given visitor.
*
* Note that {@link Files#walkFileTree(Path,FileVisitor)} returns the given path.
*
* @param start See {@link Files#walkFileTree(Path,Set,int,FileVisitor)}.
* @param options See {@link Files#walkFileTree(Path,Set,int,FileVisitor)}.
* @param maxDepth See {@link Files#walkFileTree(Path,Set,int,FileVisitor)}.
* @param visitor See {@link Files#walkFileTree(Path,Set,int,FileVisitor)}.
* @param See {@link Files#walkFileTree(Path,Set,int,FileVisitor)}.
* @return the given visitor.
*
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static > T visitFileTree(final T visitor, final Path start, final Set options,
final int maxDepth) throws IOException {
Files.walkFileTree(start, options, maxDepth, visitor);
return visitor;
}
/**
* Performs {@link Files#walkFileTree(Path,FileVisitor)} and returns the given visitor.
*
* Note that {@link Files#walkFileTree(Path,FileVisitor)} returns the given path.
*
* @param visitor See {@link Files#walkFileTree(Path,FileVisitor)}.
* @param first See {@link Paths#get(String,String[])}.
* @param more See {@link Paths#get(String,String[])}.
* @param See {@link Files#walkFileTree(Path,FileVisitor)}.
* @return the given visitor.
*
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static > T visitFileTree(final T visitor, final String first, final String... more) throws IOException {
return visitFileTree(visitor, Paths.get(first, more));
}
/**
* Performs {@link Files#walkFileTree(Path,FileVisitor)} and returns the given visitor.
*
* Note that {@link Files#walkFileTree(Path,FileVisitor)} returns the given path.
*
* @param visitor See {@link Files#walkFileTree(Path,FileVisitor)}.
* @param uri See {@link Paths#get(URI)}.
* @param See {@link Files#walkFileTree(Path,FileVisitor)}.
* @return the given visitor.
*
* @throws IOException if an I/O error is thrown by a visitor method.
*/
public static > T visitFileTree(final T visitor, final URI uri) throws IOException {
return visitFileTree(visitor, Paths.get(uri));
}
/**
* Waits for the file system to propagate a file creation, with a timeout.
*
* This method repeatedly tests {@link Files#exists(Path,LinkOption...)} until it returns true up to the maximum time given.
*
*
* @param file the file to check, must not be {@code null}.
* @param timeout the maximum time to wait.
* @param options options indicating how to handle symbolic links.
* @return true if file exists.
* @throws NullPointerException if the file is {@code null}.
* @since 2.12.0
*/
public static boolean waitFor(final Path file, final Duration timeout, final LinkOption... options) {
Objects.requireNonNull(file, "file");
final Instant finishInstant = Instant.now().plus(timeout);
boolean interrupted = false;
final long minSleepMillis = 100;
try {
while (!exists(file, options)) {
final Instant now = Instant.now();
if (now.isAfter(finishInstant)) {
return false;
}
try {
ThreadUtils.sleep(Duration.ofMillis(Math.min(minSleepMillis, finishInstant.minusMillis(now.toEpochMilli()).toEpochMilli())));
} catch (final InterruptedException ignore) {
interrupted = true;
} catch (final Exception ex) {
break;
}
}
} finally {
if (interrupted) {
Thread.currentThread().interrupt();
}
}
return exists(file, options);
}
/**
* Returns a stream of filtered paths.
*
* The returned {@link Stream} may wrap one or more {@link DirectoryStream}s. When you require timely disposal of file system resources, use a
* {@code try}-with-resources block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed. Calling a
* closed stream causes a {@link IllegalStateException}.
*
*
* @param start the start path
* @param pathFilter the path filter
* @param maxDepth the maximum depth of directories to walk.
* @param readAttributes whether to call the filters with file attributes (false passes null).
* @param options the options to configure the walk.
* @return a filtered stream of paths.
* @throws IOException if an I/O error is thrown when accessing the starting file.
* @since 2.9.0
*/
@SuppressWarnings("resource") // Caller closes
public static Stream walk(final Path start, final PathFilter pathFilter, final int maxDepth, final boolean readAttributes,
final FileVisitOption... options) throws IOException {
return Files.walk(start, maxDepth, options)
.filter(path -> pathFilter.accept(path, readAttributes ? readBasicFileAttributesUnchecked(path) : null) == FileVisitResult.CONTINUE);
}
private static R withPosixFileAttributes(final Path path, final LinkOption[] linkOptions, final boolean overrideReadOnly,
final IOFunction function) throws IOException {
final PosixFileAttributes posixFileAttributes = overrideReadOnly ? readPosixFileAttributes(path, linkOptions) : null;
try {
return function.apply(posixFileAttributes);
} finally {
if (posixFileAttributes != null && path != null && Files.exists(path, linkOptions)) {
Files.setPosixFilePermissions(path, posixFileAttributes.permissions());
}
}
}
/**
* Writes the given character sequence to a file at the given path.
*
* @param path The target file.
* @param charSequence The character sequence text.
* @param charset The Charset to encode the text.
* @param openOptions options How to open the file.
* @return The given path.
* @throws IOException if an I/O error occurs writing to or creating the file.
* @throws NullPointerException if either {@code path} or {@code charSequence} is {@code null}.
* @since 2.12.0
*/
public static Path writeString(final Path path, final CharSequence charSequence, final Charset charset, final OpenOption... openOptions)
throws IOException {
// Check the text is not null before opening file.
Objects.requireNonNull(path, "path");
Objects.requireNonNull(charSequence, "charSequence");
Files.write(path, String.valueOf(charSequence).getBytes(Charsets.toCharset(charset)), openOptions);
return path;
}
/**
* Prevents instantiation.
*/
private PathUtils() {
// do not instantiate.
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/PathVisitor.java 0100644 0000000 0000000 00000002034 14603604450 027572 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.nio.file.FileVisitor;
import java.nio.file.Path;
/**
* A {@link FileVisitor} typed to a {@link Path}.
*
* @since 2.9.0
*/
public interface PathVisitor extends FileVisitor {
// empty
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/SimplePathVisitor.java 0100644 0000000 0000000 00000003743 14603604450 030754 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.util.Objects;
import org.apache.commons.io.function.IOBiFunction;
/**
* A {@link SimpleFileVisitor} typed to a {@link Path}.
*
* @since 2.7
*/
public abstract class SimplePathVisitor extends SimpleFileVisitor implements PathVisitor {
private final IOBiFunction visitFileFailedFunction;
/**
* Constructs a new instance.
*/
protected SimplePathVisitor() {
this.visitFileFailedFunction = super::visitFileFailed;
}
/**
* Constructs a new instance.
*
* @param visitFileFailed Called on {@link #visitFileFailed(Path, IOException)}.
*/
protected SimplePathVisitor(final IOBiFunction visitFileFailed) {
this.visitFileFailedFunction = Objects.requireNonNull(visitFileFailed, "visitFileFailed");
}
@Override
public FileVisitResult visitFileFailed(final Path file, final IOException exc) throws IOException {
return visitFileFailedFunction.apply(file, exc);
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/StandardDeleteOption.java 0100644 0000000 0000000 00000003350 14603604450 031374 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file;
import java.util.stream.Stream;
import org.apache.commons.io.IOUtils;
/**
* Defines the standard delete options.
*
* @since 2.8.0
*/
public enum StandardDeleteOption implements DeleteOption {
/**
* Overrides the read-only attribute to allow deletion, on POSIX, this means Write and Execute on the parent.
*/
OVERRIDE_READ_ONLY;
/**
* Returns true if the given options contain {@link StandardDeleteOption#OVERRIDE_READ_ONLY}.
*
* For now, assume the array is not sorted.
*
* @param options the array to test
* @return true if the given options contain {@link StandardDeleteOption#OVERRIDE_READ_ONLY}.
*/
public static boolean overrideReadOnly(final DeleteOption[] options) {
if (IOUtils.length(options) == 0) {
return false;
}
return Stream.of(options).anyMatch(e -> StandardDeleteOption.OVERRIDE_READ_ONLY == e);
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/attribute/FileTimes.java 0100644 0000000 0000000 00000024417 14603604450 031213 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file.attribute;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.FileTime;
import java.time.Instant;
import java.util.Date;
import java.util.concurrent.TimeUnit;
/**
* Helps use {@link FileTime} and interoperate Date and NTFS times.
*
* @since 2.12.0
*/
public final class FileTimes {
/**
* Constant for the {@code 1970-01-01T00:00:00Z} {@link Instant#EPOCH epoch} as a time stamp attribute.
*
* @see Instant#EPOCH
*/
public static final FileTime EPOCH = FileTime.from(Instant.EPOCH);
/**
* The offset of Windows time 0 to UNIX epoch in 100-nanosecond intervals.
*
* Windows File Times
*
* A file time is a 64-bit value that represents the number of 100-nanosecond intervals that have elapsed since 12:00
* A.M. January 1, 1601 Coordinated Universal Time (UTC). This is the offset of Windows time 0 to UNIX epoch in
* 100-nanosecond intervals.
*
*/
static final long WINDOWS_EPOCH_OFFSET = -116444736000000000L;
/**
* The amount of 100-nanosecond intervals in one second.
*/
private static final long HUNDRED_NANOS_PER_SECOND = TimeUnit.SECONDS.toNanos(1) / 100;
/**
* The amount of 100-nanosecond intervals in one millisecond.
*/
static final long HUNDRED_NANOS_PER_MILLISECOND = TimeUnit.MILLISECONDS.toNanos(1) / 100;
/**
* Converts standard UNIX time (in seconds, UTC/GMT) to {@link FileTime}.
*
* @param time UNIX timestamp (seconds).
* @return the corresponding FileTime.
* @since 2.16.0
*/
public static FileTime fromUnixTime(final long time) {
return FileTime.from(time, TimeUnit.SECONDS);
}
/**
* Tests whether a FileTime can be safely represented in the standard UNIX time.
*
* If the FileTime is null, this method returns true.
*
*
* @param time the FileTime to evaluate, can be null.
* @return true if the time exceeds the minimum or maximum UNIX time, false otherwise.
* @since 2.16.0
*/
public static boolean isUnixTime(final FileTime time) {
return isUnixTime(toUnixTime(time));
}
/**
* Tests whether a given number of seconds (since Epoch) can be safely represented in the standard UNIX time.
*
* @param seconds the number of seconds (since Epoch) to evaluate.
* @return true if the time can be represented in the standard UNIX time, false otherwise.
* @since 2.16.0
*/
public static boolean isUnixTime(final long seconds) {
return Integer.MIN_VALUE <= seconds && seconds <= Integer.MAX_VALUE;
}
/**
* Subtracts milliseconds from a source FileTime.
*
* @param fileTime The source FileTime.
* @param millisToSubtract The milliseconds to subtract.
* @return The resulting FileTime.
*/
public static FileTime minusMillis(final FileTime fileTime, final long millisToSubtract) {
return FileTime.from(fileTime.toInstant().minusMillis(millisToSubtract));
}
/**
* Subtracts nanoseconds from a source FileTime.
*
* @param fileTime The source FileTime.
* @param nanosToSubtract The nanoseconds to subtract.
* @return The resulting FileTime.
*/
public static FileTime minusNanos(final FileTime fileTime, final long nanosToSubtract) {
return FileTime.from(fileTime.toInstant().minusNanos(nanosToSubtract));
}
/**
* Subtracts seconds from a source FileTime.
*
* @param fileTime The source FileTime.
* @param secondsToSubtract The seconds to subtract.
* @return The resulting FileTime.
*/
public static FileTime minusSeconds(final FileTime fileTime, final long secondsToSubtract) {
return FileTime.from(fileTime.toInstant().minusSeconds(secondsToSubtract));
}
/**
* Obtains the current instant FileTime from the system clock.
*
* @return the current instant FileTime from the system clock.
*/
public static FileTime now() {
return FileTime.from(Instant.now());
}
/**
* Converts NTFS time (100 nanosecond units since 1 January 1601) to Java time.
*
* @param ntfsTime the NTFS time in 100 nanosecond units
* @return the Date
*/
public static Date ntfsTimeToDate(final long ntfsTime) {
final long javaHundredNanos = Math.addExact(ntfsTime, WINDOWS_EPOCH_OFFSET);
final long javaMillis = Math.floorDiv(javaHundredNanos, HUNDRED_NANOS_PER_MILLISECOND);
return new Date(javaMillis);
}
/**
* Converts NTFS time (100-nanosecond units since 1 January 1601) to a FileTime.
*
* @param ntfsTime the NTFS time in 100-nanosecond units
* @return the FileTime
*
* @see #toNtfsTime(FileTime)
*/
public static FileTime ntfsTimeToFileTime(final long ntfsTime) {
final long javaHundredsNanos = Math.addExact(ntfsTime, WINDOWS_EPOCH_OFFSET);
final long javaSeconds = Math.floorDiv(javaHundredsNanos, HUNDRED_NANOS_PER_SECOND);
final long javaNanos = Math.floorMod(javaHundredsNanos, HUNDRED_NANOS_PER_SECOND) * 100;
return FileTime.from(Instant.ofEpochSecond(javaSeconds, javaNanos));
}
/**
* Adds milliseconds to a source FileTime.
*
* @param fileTime The source FileTime.
* @param millisToAdd The milliseconds to add.
* @return The resulting FileTime.
*/
public static FileTime plusMillis(final FileTime fileTime, final long millisToAdd) {
return FileTime.from(fileTime.toInstant().plusMillis(millisToAdd));
}
/**
* Adds nanoseconds from a source FileTime.
*
* @param fileTime The source FileTime.
* @param nanosToSubtract The nanoseconds to subtract.
* @return The resulting FileTime.
*/
public static FileTime plusNanos(final FileTime fileTime, final long nanosToSubtract) {
return FileTime.from(fileTime.toInstant().plusNanos(nanosToSubtract));
}
/**
* Adds seconds to a source FileTime.
*
* @param fileTime The source FileTime.
* @param secondsToAdd The seconds to add.
* @return The resulting FileTime.
*/
public static FileTime plusSeconds(final FileTime fileTime, final long secondsToAdd) {
return FileTime.from(fileTime.toInstant().plusSeconds(secondsToAdd));
}
/**
* Sets the last modified time of the given file path to now.
*
* @param path The file path to set.
* @throws IOException if an I/O error occurs.
*/
public static void setLastModifiedTime(final Path path) throws IOException {
Files.setLastModifiedTime(path, now());
}
/**
* Converts {@link FileTime} to a {@link Date}. If the provided FileTime is {@code null}, the returned Date is also
* {@code null}.
*
* @param fileTime the file time to be converted.
* @return a {@link Date} which corresponds to the supplied time, or {@code null} if the time is {@code null}.
* @see #toFileTime(Date)
*/
public static Date toDate(final FileTime fileTime) {
return fileTime != null ? new Date(fileTime.toMillis()) : null;
}
/**
* Converts {@link Date} to a {@link FileTime}. If the provided Date is {@code null}, the returned FileTime is also
* {@code null}.
*
* @param date the date to be converted.
* @return a {@link FileTime} which corresponds to the supplied date, or {@code null} if the date is {@code null}.
* @see #toDate(FileTime)
*/
public static FileTime toFileTime(final Date date) {
return date != null ? FileTime.fromMillis(date.getTime()) : null;
}
/**
* Converts a {@link Date} to NTFS time.
*
* @param date the Date
* @return the NTFS time
*/
public static long toNtfsTime(final Date date) {
final long javaHundredNanos = date.getTime() * HUNDRED_NANOS_PER_MILLISECOND;
return Math.subtractExact(javaHundredNanos, WINDOWS_EPOCH_OFFSET);
}
/**
* Converts a {@link FileTime} to NTFS time (100-nanosecond units since 1 January 1601).
*
* @param fileTime the FileTime
* @return the NTFS time in 100-nanosecond units
*/
public static long toNtfsTime(final FileTime fileTime) {
final Instant instant = fileTime.toInstant();
final long javaHundredNanos = instant.getEpochSecond() * HUNDRED_NANOS_PER_SECOND + instant.getNano() / 100;
return Math.subtractExact(javaHundredNanos, WINDOWS_EPOCH_OFFSET);
}
/**
* Converts Java time (milliseconds since Epoch) to NTFS time.
*
* @param javaTime the Java time
* @return the NTFS time
* @since 2.16.0
*/
public static long toNtfsTime(final long javaTime) {
final long javaHundredNanos = javaTime * HUNDRED_NANOS_PER_MILLISECOND;
return Math.subtractExact(javaHundredNanos, WINDOWS_EPOCH_OFFSET);
}
/**
* Converts {@link FileTime} to standard UNIX time in seconds.
*
* The returned seconds value may lie out of bounds of UNIX time. Check with {@link FileTimes#isUnixTime(long)}.
*
*
* @param fileTime the original FileTime.
* @return the UNIX timestamp or 0 if the input is null.
* @see #isUnixTime(long)
* @since 2.16.0
*/
public static long toUnixTime(final FileTime fileTime) {
return fileTime != null ? fileTime.to(TimeUnit.SECONDS) : 0;
}
private FileTimes() {
// No instances.
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/attribute/package-info.java 0100644 0000000 0000000 00000001630 14603604450 031646 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/**
* Provides help using {@link java.nio.file.attribute} types.
*/
package org.apache.commons.io.file.attribute;
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/package-info.java 0100644 0000000 0000000 00000001616 14603604450 027647 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/**
* Provides extensions in the realm of {@link java.nio.file}.
*/
package org.apache.commons.io.file;
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/spi/FileSystemProviders.java 0100644 0000000 0000000 00000007316 14603604450 032103 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.file.spi;
import java.net.URI;
import java.net.URL;
import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.nio.file.spi.FileSystemProvider;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
/**
* Helps to work with {@link FileSystemProvider}.
*
* @since 2.9.0
*/
public class FileSystemProviders { // NOPMD Class will be final in 3.0.
private static final FileSystemProviders INSTALLED = new FileSystemProviders(FileSystemProvider.installedProviders());
/**
* Gets the {@link FileSystemProvider} for the given Path.
*
* @param path The Path to query
* @return the {@link FileSystemProvider} for the given Path.
*/
@SuppressWarnings("resource") // FileSystem is not allocated here.
public static FileSystemProvider getFileSystemProvider(final Path path) {
return Objects.requireNonNull(path, "path").getFileSystem().provider();
}
/**
* Returns the instance for the installed providers.
*
* @return the instance for the installed providers.
* @see FileSystemProvider#installedProviders()
*/
public static FileSystemProviders installed() {
return INSTALLED;
}
private final List providers;
/*
* Might make public later.
*/
private FileSystemProviders(final List providers) {
this.providers = providers != null ? providers : Collections.emptyList();
}
/**
* Gets the {@link FileSystemProvider} for the given scheme.
*
* @param scheme The scheme to query.
* @return the {@link FileSystemProvider} for the given URI or null.
*/
@SuppressWarnings("resource") // FileSystems.getDefault() returns a constant.
public FileSystemProvider getFileSystemProvider(final String scheme) {
Objects.requireNonNull(scheme, "scheme");
// Check default provider first to avoid loading of installed providers.
if (scheme.equalsIgnoreCase("file")) {
return FileSystems.getDefault().provider();
}
// Find provider.
return providers.stream().filter(provider -> provider.getScheme().equalsIgnoreCase(scheme)).findFirst().orElse(null);
}
/**
* Gets the {@link FileSystemProvider} for the given URI.
*
* @param uri The URI to query
* @return the {@link FileSystemProvider} for the given URI or null.
*/
public FileSystemProvider getFileSystemProvider(final URI uri) {
return getFileSystemProvider(Objects.requireNonNull(uri, "uri").getScheme());
}
/**
* Gets the {@link FileSystemProvider} for the given URL.
*
* @param url The URL to query
* @return the {@link FileSystemProvider} for the given URI or null.
*/
public FileSystemProvider getFileSystemProvider(final URL url) {
return getFileSystemProvider(Objects.requireNonNull(url, "url").getProtocol());
}
}
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/file/spi/package-info.java 0100644 0000000 0000000 00000001651 14603604450 030441 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/**
* Provides extensions in the realm of {@link java.nio.file.spi}.
*
* @since 2.9.0
*/
package org.apache.commons.io.file.spi;
commons-io-2.16.1-src/src/main/java/org/apache/commons/io/filefilter/AbstractFileFilter.java 0100644 0000000 0000000 00000012550 14603604450 032241 0 ustar 00root root 0000000 0000000 /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.io.filefilter;
import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.List;
import java.util.Objects;
import org.apache.commons.io.file.PathFilter;
import org.apache.commons.io.file.PathVisitor;
import org.apache.commons.io.function.IOSupplier;
/**
* Abstracts the implementation of the {@link FileFilter} (IO), {@link FilenameFilter} (IO), {@link PathFilter} (NIO)
* interfaces via our own {@link IOFileFilter} interface.
*