de.unkrig.commons.io

Class IoUtil

java.lang.Object

de.unkrig.commons.io.IoUtil

public final class IoUtil
extends Object

Various java.io-related utility methods.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	IoUtil.CollisionStrategy Determines the behavior of the copyTree(File, File, CollisionStrategy) and copyTree(File, File, CollisionStrategy) methods when files collide while copying.
static interface	IoUtil.WritingRunnable An entity which writes characters to a Writer.

Field Summary

Fields

Modifier and Type	Field and Description
static InputStream	EMPTY_INPUT_STREAM An InputStream that produces exactly 0 bytes.
static OutputStream	NULL_OUTPUT_STREAM An OutputStream that discards all bytes written to it.
static InputStream	ZERO_INPUT_STREAM An input stream that reads an endless stream of zeros.

Method Summary

Modifier and Type	Method and Description
static <EX extends Throwable> void	asFile(InputStream inputStream, boolean closeInputStream, String prefix, String suffix, File directory, ConsumerWhichThrows<? super File,? extends EX> delegate) Creates a temporary file, stores all data that can be read from the inputStream into it, closes the file, invokes the delegate with the file, and eventually deletes the file.
static Reader	asReader(CharSequence cs) Wraps the given CharSequence in a Reader - much more efficient than "new StringReader(cs.toString)".
static OutputStream	byteConsumerOutputStream(ConsumerWhichThrows<? super Byte,? extends IOException> delegate)
static InputStream	byteProducerInputStream(Producer<? extends Byte> delegate)
static InputStream	byteProducerInputStream(ProducerWhichThrows<? extends Byte,? extends IOException> delegate)
static OutputStream[]	compareOutput(int n, Runnable whenIdentical, Runnable whenNotIdentical) Creates and returns an array of n OutputStreams.
static InputStream	constantInputStream(byte b)
static long	copy(File inputFile, File outputFile) Copies the contents of the inputFile to the outputFile.
static long	copy(File inputFile, File outputFile, IoUtil.CollisionStrategy collisionStrategy) Copies the contents of the inputFile to the outputFile.
static long	copy(File inputFile, OutputStream outputStream, boolean closeOutputStream) Copies the contents of the inputFile to the outputStream.
static long	copy(InputStream inputStream, boolean closeInputStream, File outputFile) Copies the contents of the inputStream to the outputFile.
static long	copy(InputStream inputStream, boolean closeInputStream, File outputFile, boolean append) Copies the contents of the inputStream to the outputFile.
static long	copy(InputStream inputStream, boolean closeInputStream, File outputFile, IoUtil.CollisionStrategy collisionStrategy) Copies the contents of the inputStream to the outputFile.
static long	copy(InputStream inputStream, boolean closeInputStream, OutputStream outputStream, boolean closeOutputStream) Copies the contents of the inputStream to the outputStream.
static long	copy(InputStream inputStream, OutputStream outputStream) Reads the input stream until end-of-input and writes all data to the output stream.
static long	copy(InputStream inputStream, OutputStream outputStream, long n) Reads at most n bytes from the inputStream and writes all data to the outputStream.
static long	copy(Readable r, Appendable a) Reads the Readable until end-of-input and writes all data to the Appendable.
static long	copy(Reader reader, boolean closeReader, File outputFile, boolean append, Charset outputCharset) Copies the contents of the reader to the outputFile, encoded with the given outputCharset.
static long	copy(Reader reader, boolean closeReader, Writer writer, boolean closeWriter) Copies the contents of the reader to the writer.
static long	copy(Reader reader, OutputStream outputStream, Charset charset) Reads the reader until end-of-input and writes all data to the output stream.
static long	copy(Reader reader, Writer writer) Reads the reader until end-of-input and writes all data to the writer.
static long	copyAvailable(InputStream inputStream, OutputStream outputStream) Reads data from the input stream and writes it to the output stream.
static long	copyAvailable(InputStream inputStream, OutputStream outputStream, long n) Reads at most n bytes from the input stream and writes all data to the output stream.
static ConsumerWhichThrows<OutputStream,IOException>	copyFrom(InputStream inputStream)
static void	copyResource(Class<?> clasS, String resourceName, File toFile, boolean createMissingParentDirectories) Copies the contents a resource to the given toFile.
static void	copyResource(Class<?> clasS, String resourceName, OutputStream outputStream, boolean closeOutputStream) Copies the contents a resource to the given outputStream.
static void	copyResource(ClassLoader classLoader, String resourceName, File toFile, boolean createMissingParentDirectories) Copies the contents a resource to the given toFile.
static void	copyResource(ClassLoader classLoader, String resourceName, OutputStream outputStream, boolean closeOutputStream) Copies the contents of a resource to the given outputStream.
static RunnableWhichThrows<IOException>	copyRunnable(InputStream in, OutputStream out) Creates and returns a RunnableWhichThrows that copies bytes from in to out until end-of-input.
static void	copyTree(File source, File destination, IoUtil.CollisionStrategy collisionStrategy) Copies a directory tree.
static void	copyTree(URL source, File destination, IoUtil.CollisionStrategy collisionStrategy) Copies a resource tree to a directory in the file system.
static void	createMissingParentDirectoriesFor(File file) Creates any missing parent directories for the given file.
protected static InputStream	deleteOnClose(InputStream delegate, File file)
static void	fill(OutputStream outputStream, byte b, long count) Writes count bytes of value b to the given outputStream.
static URL	findOnPath(File[] path, String resourceName) Finds and returns a named resource along a "path", e.g. a Java "class path" or "source path".
static boolean	isContentIdentical(File file1, File file2)
static OutputStream	lengthWritten(Consumer<? super Integer> delegate) Creates and returns an OutputStream which ignores the data written to it and only honors the number of bytes written: Every time data is written to the OutputStream, it invokes the consume() method on the delegate with the number of bytes written (not the cumulated number of bytes written!).
static InputStream	onEndOfInput(InputStream delegate, Runnable runnable) Creates and returns an InputStream that reads from the delegate and invokes the runnable on the first end-of-input condition.
static <EX extends Throwable> void	outputFile(File file, ConsumerWhichThrows<? super File,? extends EX> delegate, boolean createMissingParentDirectories) Creates a temporary file, invokes the delegate with that file, and eventually renames the temporary file to its "real" name (replacing a possibly existing file).
static <EX extends Throwable> void	outputFileOutputStream(File file, ConsumerWhichThrows<? super OutputStream,? extends EX> delegate, boolean createMissingParentDirectories) Lets the delegate write to an OutputStream (effectively a temporary file), and eventually renames the temporary file to "file" (replacing a possibly existing file).
static <EX extends Throwable> void	outputFilePrintWriter(File file, Charset charset, ConsumerWhichThrows<? super PrintWriter,? extends EX> printer) Equivalent with printToFile(file, charset, printer, false).
static <EX extends Throwable> void	outputFilePrintWriter(File file, Charset charset, ConsumerWhichThrows<? super PrintWriter,? extends EX> delegate, boolean createMissingParentDirectories) Lets the delegate print to a PrintWriter (effectively a temporary file), and eventually renames the temporary file to "file" (replacing a possibly existing file).
static void	parallel(IoUtil.WritingRunnable[] writingRunnables, Writer writer) Executes the writingRunnables in parallel, concatenates their output, and writes it to the writer, i.e. the output of the runnables does not mix, but the complete output of the first runnable appears before that of the second runnable, and so on.
static InputStream	randomInputStream(long seed)
static byte[]	readAll(InputStream is)
static String	readAll(InputStream inputStream, Charset charset, boolean closeInputStream)
static String	readAll(Reader reader)
static String	readAll(Reader reader, boolean closeReader)
static long	skip(InputStream inputStream, long n) Skips n bytes on the inputStream.
static long	skipAll(InputStream inputStream) Skips all remaining data on the inputStream.
static OutputStream	split(ProducerWhichThrows<? extends OutputStream,? extends IOException> delegates, Producer<? extends Long> byteCountLimits) Creates and returns an OutputStream which writes at most byteCountLimits.produce() bytes to delegates.produce() before closing it and writing the next byteCountLimits.produce() bytes to delegates.produce(), and so on.
static OutputStream	tee(OutputStream... delegates) Creates and returns an OutputStream that delegates all work to the given delegates: The write() methods write the given data to all the delegates; if any of these throw an IOException, it is rethrown, and it is undefined whether all the data was written to all the delegates.
static InputStream	unclosableInputStream(InputStream delegate)
static OutputStream	unclosableOutputStream(OutputStream delegate)
static long	writeAndCount(ConsumerWhichThrows<? super OutputStream,? extends IOException> writeContents, OutputStream outputStream) Invokes writeContents.consume() with an output stream subject that writes the data through to the given outputStream.
static InputStream	wye(InputStream in, OutputStream out) Creates and returns a FilterInputStream that duplicates all bytes read through it and writes them to an OutputStream.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

EMPTY_INPUT_STREAM

public static final InputStream EMPTY_INPUT_STREAM

An InputStream that produces exactly 0 bytes.

NULL_OUTPUT_STREAM

public static final OutputStream NULL_OUTPUT_STREAM

An OutputStream that discards all bytes written to it.

ZERO_INPUT_STREAM

public static final InputStream ZERO_INPUT_STREAM

An input stream that reads an endless stream of zeros.

Method Detail

findOnPath

@Nullable
public static URL findOnPath(@Nullable
                                        File[] path,
                                        String resourceName)
                                 throws IOException

Finds and returns a named resource along a "path", e.g. a Java "class path" or "source path".

Parameters:

path - Each element should designate either a directory or a JAR (or ZIP) file

Returns:

null if path == null, or if the resource could not be found

Throws:

IOException

copy

public static long copy(InputStream inputStream,
                        OutputStream outputStream)
                 throws IOException

Reads the input stream until end-of-input and writes all data to the output stream. Closes none of the two streams.

Returns:

The number of bytes copied

Throws:

IOException

copy

public static long copy(InputStream inputStream,
                        OutputStream outputStream,
                        long n)
                 throws IOException

Reads at most n bytes from the inputStream and writes all data to the outputStream. Closes none of the two streams.

Returns:

The number of bytes copied

Throws:

IOException

copy

public static long copy(InputStream inputStream,
                        boolean closeInputStream,
                        OutputStream outputStream,
                        boolean closeOutputStream)
                 throws IOException

Copies the contents of the inputStream to the outputStream.

Parameters:

closeInputStream - Whether to close the inputStream (also if an IOException is thrown)

closeOutputStream - Whether to close the outputStream (also if an IOException is thrown)

Returns:

The number of bytes copied

Throws:

IOException

copyRunnable

public static RunnableWhichThrows<IOException> copyRunnable(InputStream in,
                                                            OutputStream out)

Creates and returns a RunnableWhichThrows that copies bytes from in to out until end-of-input.

copy

public static long copy(Reader reader,
                        Writer writer)
                 throws IOException

Reads the reader until end-of-input and writes all data to the writer. Closes neither the reader nor the writer.

Returns:

The number of characters copied

Throws:

IOException

copy

public static long copy(Reader reader,
                        boolean closeReader,
                        Writer writer,
                        boolean closeWriter)
                 throws IOException

Copies the contents of the reader to the writer.

Returns:

The number of characters copied

Throws:

IOException

copy

public static long copy(Reader reader,
                        OutputStream outputStream,
                        Charset charset)
                 throws IOException

Reads the reader until end-of-input and writes all data to the output stream. Closes neither the reader nor the output stream.

Returns:

The number of characters copied

Throws:

IOException

copy

public static long copy(Readable r,
                        Appendable a)
                 throws IOException

Reads the Readable until end-of-input and writes all data to the Appendable.

Returns:

The number of characters copied

Throws:

IOException

copy

public static long copy(InputStream inputStream,
                        boolean closeInputStream,
                        File outputFile,
                        boolean append)
                 throws IOException

Copies the contents of the inputStream to the outputFile. Attempts to delete a partially written output file if the operation fails.

Returns:

The number of bytes copied

Throws:

IOException

copy

public static long copy(Reader reader,
                        boolean closeReader,
                        File outputFile,
                        boolean append,
                        Charset outputCharset)
                 throws IOException

Copies the contents of the reader to the outputFile, encoded with the given outputCharset. Attempts to delete a partially written output file if the operation fails.

Returns:

The number of characters copied

Throws:

IOException

copy

public static long copy(File inputFile,
                        OutputStream outputStream,
                        boolean closeOutputStream)
                 throws IOException

Copies the contents of the inputFile to the outputStream.

Parameters:

closeOutputStream - Whether to close the outputStream when execution completes

Returns:

The number of bytes copied

Throws:

IOException

copy

public static long copy(InputStream inputStream,
                        boolean closeInputStream,
                        File outputFile)
                 throws IOException

Copies the contents of the inputStream to the outputFile.

The parent directory of the outputFile must already exist.

Returns:

The number of bytes copied

Throws:

IOException

copy

public static long copy(InputStream inputStream,
                        boolean closeInputStream,
                        File outputFile,
                        IoUtil.CollisionStrategy collisionStrategy)
                 throws IOException

Copies the contents of the inputStream to the outputFile.

The parent directory of the outputFile must already exist.

Returns:

The number of bytes copied

Throws:

IOException

copy

public static long copy(File inputFile,
                        File outputFile)
                 throws IOException

Copies the contents of the inputFile to the outputFile.

If the output file already exists, it is silently re-created (and its original content is lost).

The parent directory of the outputFile must already exist.

Returns:

The number of bytes copied

Throws:

IOException

copy

public static long copy(File inputFile,
                        File outputFile,
                        IoUtil.CollisionStrategy collisionStrategy)
                 throws IOException

Copies the contents of the inputFile to the outputFile.

If the output file already exists, then the collisionStartegy determines what is done.

The parent directory of the outputFile must already exist.

Returns:

The number of bytes copied, or -1 iff the outputFile exists and collisionStrategy == IoUtil.CollisionStrategy.LEAVE_OLD || collisionStrategy == IoUtil.CollisionStrategy.IO_EXCEPTION_IF_DIFFERENT

Throws:

IOException

See Also:

IoUtil.CollisionStrategy

copyTree

public static void copyTree(File source,
                            File destination,
                            IoUtil.CollisionStrategy collisionStrategy)
                     throws IOException

Copies a directory tree.

Iff the source is a normal file, then copy(File, File, CollisionStrategy) is called.

Otherwise, the destination is created as a directory (if it did not exist), and all members of the source directory are recursively copied to the destination directory.

The parent directory for the destination must already exist.

Throws:

IOException

copyTree

public static void copyTree(URL source,
                            File destination,
                            IoUtil.CollisionStrategy collisionStrategy)
                     throws IOException

Copies a resource tree to a directory in the file system.

Iff the source is a "content resource", then copy(InputStream, boolean, File) is called.

Otherwise, the destination is created as a directory (if it did not exist), and all members of the source directory are recursively copied to the destination directory.

The parent directory for the destination must already exist.

Throws:

IOException

copyFrom

public static ConsumerWhichThrows<OutputStream,IOException> copyFrom(InputStream inputStream)

Returns:

A Comsumer<OutputStream> which copies inputStream to its subject

isContentIdentical

public static boolean isContentIdentical(File file1,
                                         File file2)
                                  throws IOException

Returns:

Whether the contents of the two files is byte-wise identical

Throws:

IOException

tee

public static OutputStream tee(OutputStream... delegates)

Creates and returns an OutputStream that delegates all work to the given delegates:

• The write() methods write the given data to all the delegates; if any of these throw an IOException, it is rethrown, and it is undefined whether all the data was written to all the delegates.
• flush() flushes the delegates; throws the first IOException that any of the delegates throws.
• close() attempts to close all the delegates; if any of these throw IOExceptions, one of them is rethrown.

wye

public static InputStream wye(InputStream in,
                              OutputStream out)

Creates and returns a FilterInputStream that duplicates all bytes read through it and writes them to an OutputStream.

The OutputStream is flushed on end-of-input and calls to InputStream.available().

writeAndCount

public static long writeAndCount(ConsumerWhichThrows<? super OutputStream,? extends IOException> writeContents,
                                 OutputStream outputStream)
                          throws IOException

Invokes writeContents.consume() with an output stream subject that writes the data through to the given outputStream.

Returns:

The number of bytes that were written through

Throws:

IOException

parallel

public static void parallel(IoUtil.WritingRunnable[] writingRunnables,
                            Writer writer)

Executes the writingRunnables in parallel, concatenates their output, and writes it to the writer, i.e. the output of the runnables does not mix, but the complete output of the first runnable appears before that of the second runnable, and so on.

Since the character buffer for each IoUtil.WritingRunnable has a limited size, the runnables with higher indexes tend to block if the runnables with lower indexes do not complete quickly enough.

readAll

public static byte[] readAll(InputStream is)
                      throws IOException

Returns:

All bytes that the given InputStream produces

Throws:

IOException

readAll

public static String readAll(InputStream inputStream,
                             Charset charset,
                             boolean closeInputStream)
                      throws IOException

Returns:

All bytes that the given InputStream produces, decoded into a string

Throws:

IOException

skip

public static long skip(InputStream inputStream,
                        long n)
                 throws IOException

Skips n bytes on the inputStream. Notice that InputStream.skip(long) sometimes skips less than the requested number of bytes for no good reason, e.g. BufferedInputStream.skip(long) is known for that. This method tries "harder" to skip exactly the requested number of bytes.

Returns:

The number of bytes that were skipped

Throws:

IOException

See Also:

InputStream.skip(long)

skipAll

public static long skipAll(InputStream inputStream)
                    throws IOException

Skips all remaining data on the inputStream.

Returns:

The number of bytes that were skipped

Throws:

IOException

See Also:

InputStream.skip(long)

split

public static OutputStream split(ProducerWhichThrows<? extends OutputStream,? extends IOException> delegates,
                                 Producer<? extends Long> byteCountLimits)
                          throws IOException

Creates and returns an OutputStream which writes at most byteCountLimits.produce() bytes to delegates.produce() before closing it and writing the next byteCountLimits.produce() bytes to delegates.produce(), and so on.

Parameters:

delegates - Must produce a (non-null) series of OutputStreams

byteCountLimits - Must produce a (non-null) series of Longs

Throws:

IOException

constantInputStream

public static InputStream constantInputStream(byte b)

Returns:

An input stream that reads an endless stream of bytes of value b

unclosableInputStream

public static InputStream unclosableInputStream(InputStream delegate)

Returns:

An InputStream which ignores all invocations of InputStream.close()

unclosableOutputStream

public static OutputStream unclosableOutputStream(OutputStream delegate)

Returns:

An OutputStream which ignores all invocations of OutputStream.close()

fill

public static void fill(OutputStream outputStream,
                        byte b,
                        long count)
                 throws IOException

Writes count bytes of value b to the given outputStream.

Throws:

IOException

byteProducerInputStream

public static InputStream byteProducerInputStream(ProducerWhichThrows<? extends Byte,? extends IOException> delegate)

Returns:

An input stream which reads the data produced by the delegate byte producer; null products are returned as 'end-of-input'

byteProducerInputStream

public static InputStream byteProducerInputStream(Producer<? extends Byte> delegate)

Returns:

An input stream which reads the data produced by the delegate byte producer; null products are returned as 'end-of-input'

randomInputStream

public static InputStream randomInputStream(long seed)

Returns:

An input stream which reads and endless stream of random bytes

byteConsumerOutputStream

public static OutputStream byteConsumerOutputStream(ConsumerWhichThrows<? super Byte,? extends IOException> delegate)

Returns:

An output stream which feeds the data to the delegate byte consumer

readAll

public static String readAll(Reader reader)
                      throws IOException

Returns:

All characters that the given Reader produces

Throws:

IOException

readAll

public static String readAll(Reader reader,
                             boolean closeReader)
                      throws IOException

Parameters:

closeReader - Whether the reader should be closed before the method returns

Returns:

All characters that the given Reader produces

Throws:

IOException

deleteOnClose

protected static InputStream deleteOnClose(InputStream delegate,
                                           File file)

Returns:

An InputStream which first closes the delegate, and then attempts to delete the file

compareOutput

public static OutputStream[] compareOutput(int n,
                                           Runnable whenIdentical,
                                           Runnable whenNotIdentical)

Creates and returns an array of n OutputStreams.

Iff exactly the same bytes are written to all of these streams, and then all the streams are closed, then whenIdentical will be run (exactly once).

Otherwise, when the first non-identical byte is written to one of the streams, or at the latest when that stream is closed, whenNotIdentical will be run (possibly more than once).

lengthWritten

public static OutputStream lengthWritten(Consumer<? super Integer> delegate)

Creates and returns an OutputStream which ignores the data written to it and only honors the number of bytes written:

Every time data is written to the OutputStream, it invokes the consume() method on the delegate with the number of bytes written (not the cumulated number of bytes written!).

asReader

public static Reader asReader(CharSequence cs)

Wraps the given CharSequence in a Reader - much more efficient than "new StringReader(cs.toString)".

copyResource

public static void copyResource(ClassLoader classLoader,
                                String resourceName,
                                OutputStream outputStream,
                                boolean closeOutputStream)
                         throws IOException

Copies the contents of a resource to the given outputStream.

The resource is addressed by the classLoader and the resourceName, as described for ClassLoader.getResourceAsStream(String).

Parameters:

closeOutputStream - Whether the outputStream should be closed after the content of the resource has been copied

Throws:

IOException

copyResource

public static void copyResource(Class<?> clasS,
                                String resourceName,
                                OutputStream outputStream,
                                boolean closeOutputStream)
                         throws IOException

Copies the contents a resource to the given outputStream.

The resource is addressed by the clasS and the resourceName, as described for Class.getResourceAsStream(String).

Parameters:

closeOutputStream - Whether the outputStream should be closed after the content of the resource has been copied

Throws:

IOException

copyResource

public static void copyResource(ClassLoader classLoader,
                                String resourceName,
                                File toFile,
                                boolean createMissingParentDirectories)
                         throws IOException

Copies the contents a resource to the given toFile.

The resource is addressed by the classLoader and the resourceName, as described for ClassLoader.getResourceAsStream(String).

Parameters:

createMissingParentDirectories - Whether to create any missing parent directories for the toFile

Throws:

IOException

copyResource

public static void copyResource(Class<?> clasS,
                                String resourceName,
                                File toFile,
                                boolean createMissingParentDirectories)
                         throws IOException

Copies the contents a resource to the given toFile.

The resource is addressed by the clasS and the resourceName, as described for Class.getResourceAsStream(String).

Parameters:

createMissingParentDirectories - Whether to create any missing parent directories for the toFile

Throws:

IOException

asFile

public static <EX extends Throwable> void asFile(InputStream inputStream,
                                                 boolean closeInputStream,
                                                 @Nullable
                                                 String prefix,
                                                 @Nullable
                                                 String suffix,
                                                 @Nullable
                                                 File directory,
                                                 ConsumerWhichThrows<? super File,? extends EX> delegate)
                                          throws IOException,
                                                 EX extends Throwable

Creates a temporary file, stores all data that can be read from the inputStream into it, closes the file, invokes the delegate with the file, and eventually deletes the file.

Throws:

IOException

EX extends Throwable

See Also:

File.createTempFile(String, String, File)

outputFilePrintWriter

public static <EX extends Throwable> void outputFilePrintWriter(File file,
                                                                Charset charset,
                                                                ConsumerWhichThrows<? super PrintWriter,? extends EX> printer)
                                                         throws IOException,
                                                                EX extends Throwable

Equivalent with printToFile(file, charset, printer, false).

Throws:

IOException

EX extends Throwable

outputFilePrintWriter

public static <EX extends Throwable> void outputFilePrintWriter(File file,
                                                                Charset charset,
                                                                ConsumerWhichThrows<? super PrintWriter,? extends EX> delegate,
                                                                boolean createMissingParentDirectories)
                                                         throws IOException,
                                                                EX extends Throwable

Lets the delegate print to a PrintWriter (effectively a temporary file), and eventually renames the temporary file to "file" (replacing a possibly existing file).

In case anthing goes wrong, the temporary file is deleted, and a possibly existing "original" file remains unchanged.

Parameters:

delegate - Prints text to the PrintWriter it receives

charset - The charset to be used for printing

createMissingParentDirectories - Whether to create any missing parent directories for the file

Throws:

IOException - Creating the temporary file failed

IOException - Closing the temporary file failed

IOException - Deleting the original file (immediately before renaming the temporary file) failed

IOException - Renaming the temporary file failed

EX - The throwable that the delegate may throw

EX extends Throwable

outputFileOutputStream

public static <EX extends Throwable> void outputFileOutputStream(File file,
                                                                 ConsumerWhichThrows<? super OutputStream,? extends EX> delegate,
                                                                 boolean createMissingParentDirectories)
                                                          throws IOException,
                                                                 EX extends Throwable

Lets the delegate write to an OutputStream (effectively a temporary file), and eventually renames the temporary file to "file" (replacing a possibly existing file).

In case anthing goes wrong, the temporary file is deleted, and a possibly existing "original" file remains unchanged.

Throws:

IOException - Creating the temporary file failed

IOException - Closing the temporary file failed

IOException - Deleting the original file (immediately before renaming the temporary file) failed

IOException - Renaming the temporary file failed

EX - The delegate threw an EX

EX extends Throwable

outputFile

public static <EX extends Throwable> void outputFile(File file,
                                                     ConsumerWhichThrows<? super File,? extends EX> delegate,
                                                     boolean createMissingParentDirectories)
                                              throws IOException,
                                                     EX extends Throwable

Creates a temporary file, invokes the delegate with that file, and eventually renames the temporary file to its "real" name (replacing a possibly existing file).

In case anthing goes wrong, the temporary file is deleted, and a possibly existing "original" file remains unchanged.

Throws:

IOException - Deleting the original file (immediately before renaming the temporary file) failed

IOException - Renaming the temporary file failed

EX - The delegate threw an EX

EX extends Throwable

createMissingParentDirectoriesFor

public static void createMissingParentDirectoriesFor(File file)
                                              throws IOException

Creates any missing parent directories for the given file.

Throws:

IOException - A directory is missing, but could not be created

IOException - A non-directory (e.g. a "normal" file) is in the way

copyAvailable

public static long copyAvailable(InputStream inputStream,
                                 OutputStream outputStream)
                          throws IOException

Reads data from the input stream and writes it to the output stream. Closes none of the two streams. Returns when no data is available on the inputStream.

Returns:

The number of bytes copied

Throws:

IOException

copyAvailable

public static long copyAvailable(InputStream inputStream,
                                 OutputStream outputStream,
                                 long n)
                          throws IOException

Reads at most n bytes from the input stream and writes all data to the output stream. Closes none of the two streams. Returns when no data is available on the inputStream.

Returns:

The number of bytes copied

Throws:

IOException

onEndOfInput

public static InputStream onEndOfInput(InputStream delegate,
                                       Runnable runnable)

Creates and returns an InputStream that reads from the delegate and invokes the runnable on the first end-of-input condition.