IOUtil (lecousin.net Java core framework 0.16.2 API)

java.lang.Object
- net.lecousin.framework.io.IOUtil

public final class IOUtil
extends Object

Utility methods for IO.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class IOUtil.RecursiveAsyncSupplierListener<T>
Recursive listener, forwarding error or cancel and calling onDone on error.

Nested Classes
Modifier and Type	Class and Description
`static class`	`IOUtil.RecursiveAsyncSupplierListener<T>` Recursive listener, forwarding error or cancel and calling onDone on error.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static IAsync<IOException>`	`closeAsync(Closeable toClose)` Implement an asynchronous close using a task calling the synchronous close.
`static AsyncSupplier<Long,IOException>`	`copy(File src, File dst, byte priority, long knownSize, WorkProgress progress, long work, IAsync<?> startOn)` Copy a file.
`static AsyncSupplier<Long,IOException>`	`copy(IO.Readable input, IO.Writable output, long size, boolean closeIOs, WorkProgress progress, long work)` Copy from a Readable to a Writable.
`static <T extends IO.Writable.Seekable & IO.Readable.Seekable> Async<IOException>`	`copy(T io, long src, long dst, long len)` Copy bytes inside a Seekable IO.
`static <TResult,TError extends Exception> void`	`error(TError error, AsyncSupplier<TResult,TError> result, Consumer<Pair<TResult,TError>> ondone)` Shortcut to transfer an error to ondone if it is not null, and to the AsyncWork.
`static <TResult,TError extends Exception> AsyncSupplier<TResult,TError>`	`error(TError error, Consumer<Pair<TResult,TError>> ondone)` Shortcut to transfer an error to ondone if it is not null, and create an AsyncWork with this error.
`static <T> Consumer<IOException>`	`errorConsumer(IAsync<IOException> async, Consumer<Pair<T,IOException>> ondone)` Create a consumer that call forward the error to the given sync and call onDone.
`static long`	`getSizeSync(IO.Readable.Seekable io)` Get the size by seeking at the end if not an instanceof IO.KnownSize.
`static IO`	`getUnderlyingIO(IO io)` Get the underlying IO by going through the wrapped IO until the last one.
`static TaskManager`	`getUnderlyingTaskManager(IO io)` Get the underlying task manager by going through the wrapped IO.
`static <T> void`	`listenOnDone(AsyncSupplier<T,IOException> toListen, AsyncSupplier<T,IOException> toUnblock, Consumer<Pair<T,IOException>> ondone)` Listen to the given asynchronous operation, then unblock `toUnblock` with its result/error/cancellation, but calls ondone before if not null and the result is not cancelled.
`static <T,T2> void`	`listenOnDone(AsyncSupplier<T,IOException> toListen, Consumer<T> onReady, IAsync<IOException> onErrorOrCancel, Consumer<Pair<T2,IOException>> ondone)` Listen to `toListen`, then calls `onReady` if it succeed.
`static <T,T2> void`	`listenOnDone(AsyncSupplier<T,IOException> toListen, Task<?,?> onReady, IAsync<IOException> onErrorOrCancel, Consumer<Pair<T2,IOException>> ondone)` Listen to `toListen`, then launch `onReady` if it succeed.
`static <T> void`	`listenOnDone(IAsync<IOException> toListen, Runnable onReady, IAsync<IOException> onErrorOrCancel, Consumer<Pair<T,IOException>> ondone)` Listen to `toListen`, then calls `onReady` if it succeed.
`static <TResult,TError extends Exception> void`	`notSuccess(IAsync<TError> sp, AsyncSupplier<TResult,TError> result, Consumer<Pair<TResult,TError>> ondone)` Shortcut to transfer error or cancellation.
`static Task<Integer,IOException>`	`readAsyncUsingSync(IO.Readable.Seekable io, long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)` Implement an asynchronous read using a task calling the synchronous one.
`static Task<Integer,IOException>`	`readAsyncUsingSync(IO.Readable io, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)` Implement an asynchronous read using a task calling the synchronous one.
`static AsyncSupplier<byte[],IOException>`	`readFully(File file, byte priority)` Read the content of a file and return a byte array.
`static void`	`readFully(IO.Readable io, AsyncSupplier<byte[],IOException> result)` Read fully into a byte[], and unblock the given result upon completion.
`static int`	`readFully(IO.Readable io, ByteBuffer buffer)` Fill the remaining bytes of the given buffer.
`static int`	`readFully(IO.ReadableByteStream io, byte[] buffer)` Fill the given buffer.
`static int`	`readFully(IO.ReadableByteStream io, byte[] buffer, int off, int len)` Read the given number of bytes.
`static AsyncSupplier<UnprotectedStringBuffer,IOException>`	`readFullyAsString(IO.Readable io, Charset charset, byte priority)` Read all bytes from the given Readable and convert it as a String using the given charset encoding.
`static String`	`readFullyAsStringSync(File file, Charset charset)` Read all bytes from the given file and convert it as a String using the given charset encoding.
`static String`	`readFullyAsStringSync(InputStream input, Charset charset)` Read all bytes from the given InputStream and convert it as a String using the given charset encoding.
`static void`	`readFullyAsStringSync(InputStream input, Charset charset, StringBuilder s)` Read all bytes from the given Readable and append them to the given StringBuilder using the given charset encoding.
`static String`	`readFullyAsStringSync(IO.Readable io, Charset charset)` Read all bytes from the given Readable and convert it as a String using the given charset encoding.
`static void`	`readFullyAsStringSync(IO.Readable io, Charset charset, StringBuilder s)` Read all bytes from the given Readable and append them to the given StringBuilder using the given charset encoding.
`static AsyncSupplier<Integer,IOException>`	`readFullyAsync(IO.Readable.Seekable io, long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)` Fill the remaining bytes of the given buffer.
`static AsyncSupplier<Integer,IOException>`	`readFullyAsync(IO.Readable io, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)` Fill the remaining bytes of the given buffer asynchronously.
`static AsyncSupplier<Integer,IOException>`	`readFullyAsync(IO.Readable io, ByteBuffer buffer, int done, Consumer<Pair<Integer,IOException>> ondone)` Fill the remaining bytes of the given buffer asynchronously.
`static AsyncSupplier<ByteBuffersIO,IOException>`	`readFullyAsync(IO.Readable io, int bufferSize)` Read the content of IO.Readable in memory and put it into a ByteBuffersIO.
`static Task<Integer,IOException>`	`readFullyAsyncUsingSync(IO.Readable.Seekable io, long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)` Implement an asynchronous read using a task calling the synchronous one.
`static Task<Integer,IOException>`	`readFullyAsyncUsingSync(IO.Readable io, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)` Implement an asynchronous read using a task calling the synchronous one.
`static void`	`readFullyKnownSize(IO.Readable io, int size, AsyncSupplier<byte[],IOException> result)` Read fully into a byte[], and unblock the given result upon completion.
`static <T extends IO.Readable & IO.KnownSize> void`	`readFullyKnownSize(T io, AsyncSupplier<byte[],IOException> result)` Read fully into a byte[], and unblock the given result upon completion.
`static int`	`readFullySync(IO.Readable.Seekable io, long pos, ByteBuffer buffer)` Fill the remaining bytes of the given buffer.
`static int`	`readFullySyncUsingAsync(IO.Readable.Seekable io, long pos, ByteBuffer buffer)` Implement a synchronous read using an asynchronous one and blocking until it finishes.
`static int`	`readFullySyncUsingAsync(IO.Readable io, ByteBuffer buffer)` Implement a synchronous read using an asynchronous one and blocking until it finishes.
`static int`	`readSyncUsingAsync(IO.Readable.Seekable io, long pos, ByteBuffer buffer)` Implement a synchronous read using an asynchronous one and blocking until it finishes.
`static int`	`readSyncUsingAsync(IO.Readable io, ByteBuffer buffer)` Implement a synchronous read using an asynchronous one and blocking until it finishes.
`static Task<Long,IOException>`	`seekAsyncUsingSync(IO.Seekable io, IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)` Implement an asynchronous seek using a task calling a synchronous one.
`static long`	`seekSyncUsingAsync(IO.Seekable io, IO.Seekable.SeekType type, long move)` Implement a synchronous sync by calling an asynchronous one and blocking until the result is available.
`static Task<Void,IOException>`	`setSizeAsyncUsingSync(IO.Resizable io, long newSize, byte priority)` Implement an asynchronous setSize using a task calling a synchronous one.
`static AsyncSupplier<Long,IOException>`	`skipAsyncByReading(IO.Readable io, long n, Consumer<Pair<Long,IOException>> ondone)` Implement an asynchronous skip using readAsync.
`static AsyncSupplier<Long,IOException>`	`skipAsyncUsingSync(IO.Readable io, long n, Consumer<Pair<Long,IOException>> ondone)` Implement an asynchronous skip using a task calling a synchronous skip.
`static long`	`skipSyncByReading(IO.Readable io, long n)` Implement a synchronous skip using a synchronous read.
`static long`	`skipSyncUsingAsync(IO.Readable io, long n)` Implement a synchronous skip using an asynchronous one and blocking until it finishes.
`static <TResult,TError extends Exception> void`	`success(TResult res, AsyncSupplier<TResult,TError> result, Consumer<Pair<TResult,TError>> ondone)` Shortcut to transfer a result to ondone if it is not null, and to the AsyncWork.
`static <TResult,TError extends Exception> AsyncSupplier<TResult,TError>`	`success(TResult result, Consumer<Pair<TResult,TError>> ondone)` Shortcut to transfer a result to ondone if it is not null, and create an AsyncWork with this result.
`static AsyncSupplier<File,IOException>`	`toTempFile(byte[] bytes)` Create a temporary file with the given content.
`static AsyncSupplier<File,IOException>`	`toTempFile(IO.Readable io)` Write the given Readable to a temporary file, and return the temporary file.
`static Task<Integer,IOException>`	`writeAsyncUsingSync(IO.Writable.Seekable io, long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)` Implement an asynchronous write using a task calling a synchronous write.
`static Task<Integer,IOException>`	`writeAsyncUsingSync(IO.Writable io, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)` Implement an asynchronous write using a task calling a synchronous write.
`static int`	`writeSyncUsingAsync(IO.Writable.Seekable io, long pos, ByteBuffer buffer)` Implement a synchronous write using an asynchronous one and blocking until it finishes.
`static int`	`writeSyncUsingAsync(IO.Writable io, ByteBuffer buffer)` Implement a synchronous write using an asynchronous one and blocking until it finishes.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

readFully
```
public static int readFully(IO.Readable io,
                            ByteBuffer buffer)
                     throws IOException
```
Fill the remaining bytes of the given buffer.

Parameters:

io - the readable to read from

buffer - the buffer to fill

Returns:

the number of bytes read, which is less than the remaining bytes of the buffer only if the end of the IO is reached.

Throws:

IOException - in case of error reading bytes

readFully
```
public static int readFully(IO.ReadableByteStream io,
                            byte[] buffer)
                     throws IOException
```
Fill the given buffer.

Parameters:

io - the readable to read from

buffer - the buffer to fill

Returns:

the number of bytes read, which is less than the length of the buffer only if the end of the IO is reached.

Throws:

IOException - in case of error reading bytes

readFully
```
public static int readFully(IO.ReadableByteStream io,
                            byte[] buffer,
                            int off,
                            int len)
                     throws IOException
```
Read the given number of bytes.

Parameters:

io - the readable to read from

buffer - the buffer to fill

off - the offset of the buffer from which to fill

len - the number of bytes to read

Returns:

the number of bytes read, which is less than the len only if the end of the IO is reached.

Throws:

IOException - in case of error reading bytes

readFully

public static void readFully(IO.Readable io,
                             AsyncSupplier<byte[],IOException> result)

Read fully into a byte[], and unblock the given result upon completion.

readFullyKnownSize

public static <T extends IO.Readable & IO.KnownSize> void readFullyKnownSize(T io,
                                                                             AsyncSupplier<byte[],IOException> result)

Read fully into a byte[], and unblock the given result upon completion.

readFullyKnownSize

public static void readFullyKnownSize(IO.Readable io,
                                      int size,
                                      AsyncSupplier<byte[],IOException> result)

Read fully into a byte[], and unblock the given result upon completion.

readFullySync
```
public static int readFullySync(IO.Readable.Seekable io,
                                long pos,
                                ByteBuffer buffer)
                         throws IOException
```
Fill the remaining bytes of the given buffer.

Parameters:

io - the readable to read from

pos - the position in the io to start from

buffer - the buffer to fill

Returns:

the number of bytes read, which is less than the remaining bytes of the buffer only if the end of the IO is reached.

Throws:

IOException - in case of error reading bytes

readFullyAsync

public static AsyncSupplier<Integer,IOException> readFullyAsync(IO.Readable io,
                                                                ByteBuffer buffer,
                                                                Consumer<Pair<Integer,IOException>> ondone)

Fill the remaining bytes of the given buffer asynchronously.

Parameters:: io - the readable to read from; buffer - the buffer to fill; ondone - a listener to call before to return the result
Returns:: the number of bytes read, which is less than the remaining bytes of the buffer only if the end of the IO is reached.

readFullyAsync

public static AsyncSupplier<Integer,IOException> readFullyAsync(IO.Readable io,
                                                                ByteBuffer buffer,
                                                                int done,
                                                                Consumer<Pair<Integer,IOException>> ondone)

Fill the remaining bytes of the given buffer asynchronously.

Parameters:: io - the readable to read from; buffer - the buffer to fill; done - number of bytes already read (will be added to the returned number of bytes read); ondone - a listener to call before to return the result
Returns:: the number of bytes read, which is less than the remaining bytes of the buffer only if the end of the IO is reached.

readFullyAsync

public static AsyncSupplier<Integer,IOException> readFullyAsync(IO.Readable.Seekable io,
                                                                long pos,
                                                                ByteBuffer buffer,
                                                                Consumer<Pair<Integer,IOException>> ondone)

Fill the remaining bytes of the given buffer.

Parameters:: io - the readable to read from; pos - the position in the io to start from; buffer - the buffer to fill; ondone - a listener to call before to return the result
Returns:: the number of bytes read, which is less than the remaining bytes of the buffer only if the end of the IO is reached.

readFullyAsync

public static AsyncSupplier<ByteBuffersIO,IOException> readFullyAsync(IO.Readable io,
                                                                      int bufferSize)

Read the content of IO.Readable in memory and put it into a ByteBuffersIO.

readAsyncUsingSync

public static Task<Integer,IOException> readAsyncUsingSync(IO.Readable io,
                                                           ByteBuffer buffer,
                                                           Consumer<Pair<Integer,IOException>> ondone)

Implement an asynchronous read using a task calling the synchronous one. This must be used only if the synchronous read is using CPU.

Parameters:: io - the readable to read from; buffer - the buffer to fill; ondone - a listener to call before to return the result
Returns:: the number of bytes read

readAsyncUsingSync

public static Task<Integer,IOException> readAsyncUsingSync(IO.Readable.Seekable io,
                                                           long pos,
                                                           ByteBuffer buffer,
                                                           Consumer<Pair<Integer,IOException>> ondone)

Implement an asynchronous read using a task calling the synchronous one. This must be used only if the synchronous read is using CPU.

Parameters:: io - the readable to read from; pos - the position in the io to start from; buffer - the buffer to fill; ondone - a listener to call before to return the result
Returns:: the number of bytes read

readFullyAsyncUsingSync

public static Task<Integer,IOException> readFullyAsyncUsingSync(IO.Readable io,
                                                                ByteBuffer buffer,
                                                                Consumer<Pair<Integer,IOException>> ondone)

Implement an asynchronous read using a task calling the synchronous one. This must be used only if the synchronous read is using CPU.

Parameters:: io - the readable to read from; buffer - the buffer to fill; ondone - a listener to call before to return the result
Returns:: the number of bytes read

readFullyAsyncUsingSync

public static Task<Integer,IOException> readFullyAsyncUsingSync(IO.Readable.Seekable io,
                                                                long pos,
                                                                ByteBuffer buffer,
                                                                Consumer<Pair<Integer,IOException>> ondone)

Implement an asynchronous read using a task calling the synchronous one. This must be used only if the synchronous read is using CPU.

Parameters:: io - the readable to read from; pos - the position in the io to start from; buffer - the buffer to fill; ondone - a listener to call before to return the result
Returns:: the number of bytes read

skipSyncByReading

public static long skipSyncByReading(IO.Readable io,
                                     long n)
                              throws IOException

Implement a synchronous skip using a synchronous read.

Throws:: IOException

skipAsyncUsingSync

public static AsyncSupplier<Long,IOException> skipAsyncUsingSync(IO.Readable io,
                                                                 long n,
                                                                 Consumer<Pair<Long,IOException>> ondone)

Implement an asynchronous skip using a task calling a synchronous skip. This must be used only if the synchronous skip is using only CPU.

skipAsyncByReading

public static AsyncSupplier<Long,IOException> skipAsyncByReading(IO.Readable io,
                                                                 long n,
                                                                 Consumer<Pair<Long,IOException>> ondone)

Implement an asynchronous skip using readAsync.

toTempFile
```
public static AsyncSupplier<File,IOException> toTempFile(IO.Readable io)
```
Write the given Readable to a temporary file, and return the temporary file. The given IO is closed when done.

toTempFile

public static AsyncSupplier<File,IOException> toTempFile(byte[] bytes)

Create a temporary file with the given content.

readSyncUsingAsync

public static int readSyncUsingAsync(IO.Readable io,
                                     ByteBuffer buffer)
                              throws IOException

Implement a synchronous read using an asynchronous one and blocking until it finishes.

Throws:: IOException

readSyncUsingAsync

public static int readSyncUsingAsync(IO.Readable.Seekable io,
                                     long pos,
                                     ByteBuffer buffer)
                              throws IOException

Implement a synchronous read using an asynchronous one and blocking until it finishes.

Throws:: IOException

readFullySyncUsingAsync

public static int readFullySyncUsingAsync(IO.Readable io,
                                          ByteBuffer buffer)
                                   throws IOException

Implement a synchronous read using an asynchronous one and blocking until it finishes.

Throws:: IOException

readFullySyncUsingAsync

public static int readFullySyncUsingAsync(IO.Readable.Seekable io,
                                          long pos,
                                          ByteBuffer buffer)
                                   throws IOException

Implement a synchronous read using an asynchronous one and blocking until it finishes.

Throws:: IOException

skipSyncUsingAsync

public static long skipSyncUsingAsync(IO.Readable io,
                                      long n)
                               throws IOException

Implement a synchronous skip using an asynchronous one and blocking until it finishes.

Throws:: IOException

writeSyncUsingAsync

public static int writeSyncUsingAsync(IO.Writable io,
                                      ByteBuffer buffer)
                               throws IOException

Implement a synchronous write using an asynchronous one and blocking until it finishes.

Throws:: IOException

writeSyncUsingAsync

public static int writeSyncUsingAsync(IO.Writable.Seekable io,
                                      long pos,
                                      ByteBuffer buffer)
                               throws IOException

Implement a synchronous write using an asynchronous one and blocking until it finishes.

Throws:: IOException

writeAsyncUsingSync

public static Task<Integer,IOException> writeAsyncUsingSync(IO.Writable io,
                                                            ByteBuffer buffer,
                                                            Consumer<Pair<Integer,IOException>> ondone)

Implement an asynchronous write using a task calling a synchronous write. This must be used only if the synchronous write is only using CPU.

writeAsyncUsingSync

public static Task<Integer,IOException> writeAsyncUsingSync(IO.Writable.Seekable io,
                                                            long pos,
                                                            ByteBuffer buffer,
                                                            Consumer<Pair<Integer,IOException>> ondone)

Implement an asynchronous write using a task calling a synchronous write. This must be used only if the synchronous write is only using CPU.

readFullyAsString

public static AsyncSupplier<UnprotectedStringBuffer,IOException> readFullyAsString(IO.Readable io,
                                                                                   Charset charset,
                                                                                   byte priority)

Read all bytes from the given Readable and convert it as a String using the given charset encoding.

readFullyAsStringSync

public static void readFullyAsStringSync(IO.Readable io,
                                         Charset charset,
                                         StringBuilder s)
                                  throws IOException

Read all bytes from the given Readable and append them to the given StringBuilder using the given charset encoding.

Throws:: IOException

readFullyAsStringSync

public static void readFullyAsStringSync(InputStream input,
                                         Charset charset,
                                         StringBuilder s)
                                  throws IOException

Read all bytes from the given Readable and append them to the given StringBuilder using the given charset encoding.

Throws:: IOException

readFullyAsStringSync

public static String readFullyAsStringSync(IO.Readable io,
                                           Charset charset)
                                    throws IOException

Read all bytes from the given Readable and convert it as a String using the given charset encoding.

Throws:: IOException

readFullyAsStringSync

public static String readFullyAsStringSync(File file,
                                           Charset charset)
                                    throws IOException

Read all bytes from the given file and convert it as a String using the given charset encoding.

Throws:: IOException

readFullyAsStringSync

public static String readFullyAsStringSync(InputStream input,
                                           Charset charset)
                                    throws IOException

Read all bytes from the given InputStream and convert it as a String using the given charset encoding.

Throws:: IOException

seekAsyncUsingSync

public static Task<Long,IOException> seekAsyncUsingSync(IO.Seekable io,
                                                        IO.Seekable.SeekType type,
                                                        long move,
                                                        Consumer<Pair<Long,IOException>> ondone)

Implement an asynchronous seek using a task calling a synchronous one. This must be used only if the synchronous seek is only using CPU.

seekSyncUsingAsync

public static long seekSyncUsingAsync(IO.Seekable io,
                                      IO.Seekable.SeekType type,
                                      long move)
                               throws IOException

Implement a synchronous sync by calling an asynchronous one and blocking until the result is available.

Throws:: IOException

setSizeAsyncUsingSync

public static Task<Void,IOException> setSizeAsyncUsingSync(IO.Resizable io,
                                                           long newSize,
                                                           byte priority)

Implement an asynchronous setSize using a task calling a synchronous one. This must be used only if the synchronous setSize is only using CPU.

copy

public static AsyncSupplier<Long,IOException> copy(IO.Readable input,
                                                   IO.Writable output,
                                                   long size,
                                                   boolean closeIOs,
                                                   WorkProgress progress,
                                                   long work)

Copy from a Readable to a Writable.

Parameters:: input - input to read from; output - output to write to; size - number of bytes to copy, or -1 if it is not known; closeIOs - if true both IOs will be closed at the end of the copy; progress - progress; work - amount of work in the progress
Returns:: number of bytes copied

copy

public static <T extends IO.Writable.Seekable & IO.Readable.Seekable> Async<IOException> copy(T io,
                                                                                              long src,
                                                                                              long dst,
                                                                                              long len)

Copy bytes inside a Seekable IO.

Parameters:: io - the IO; src - source position; dst - target position; len - number of bytes to copy

copy

public static AsyncSupplier<Long,IOException> copy(File src,
                                                   File dst,
                                                   byte priority,
                                                   long knownSize,
                                                   WorkProgress progress,
                                                   long work,
                                                   IAsync<?> startOn)

Copy a file.

closeAsync
```
public static IAsync<IOException> closeAsync(Closeable toClose)
```
Implement an asynchronous close using a task calling the synchronous close.

readFully

public static AsyncSupplier<byte[],IOException> readFully(File file,
                                                          byte priority)

Read the content of a file and return a byte array.

getUnderlyingTaskManager
```
public static TaskManager getUnderlyingTaskManager(IO io)
```
Get the underlying task manager by going through the wrapped IO.

getUnderlyingIO
```
public static IO getUnderlyingIO(IO io)
```
Get the underlying IO by going through the wrapped IO until the last one.

listenOnDone

public static <T> void listenOnDone(AsyncSupplier<T,IOException> toListen,
                                    AsyncSupplier<T,IOException> toUnblock,
                                    Consumer<Pair<T,IOException>> ondone)

Listen to the given asynchronous operation, then unblock toUnblock with its result/error/cancellation, but calls ondone before if not null and the result is not cancelled.

listenOnDone

public static <T,T2> void listenOnDone(AsyncSupplier<T,IOException> toListen,
                                       Consumer<T> onReady,
                                       IAsync<IOException> onErrorOrCancel,
                                       Consumer<Pair<T2,IOException>> ondone)

Listen to toListen, then calls onReady if it succeed. In case of error or cancellation, the error or cancellation event is given to onErrorOrCancel. If ondone is not null, it is called before onReady and onErrorOrCancel.

listenOnDone

public static <T,T2> void listenOnDone(AsyncSupplier<T,IOException> toListen,
                                       Task<?,?> onReady,
                                       IAsync<IOException> onErrorOrCancel,
                                       Consumer<Pair<T2,IOException>> ondone)

Listen to toListen, then launch onReady if it succeed. In case of error or cancellation, the error or cancellation event is given to onErrorOrCancel. If ondone is not null, it is called before onReady and onErrorOrCancel.

listenOnDone

public static <T> void listenOnDone(IAsync<IOException> toListen,
                                    Runnable onReady,
                                    IAsync<IOException> onErrorOrCancel,
                                    Consumer<Pair<T,IOException>> ondone)

errorConsumer

public static <T> Consumer<IOException> errorConsumer(IAsync<IOException> async,
                                                      Consumer<Pair<T,IOException>> ondone)

Create a consumer that call forward the error to the given sync and call onDone.

error

public static <TResult,TError extends Exception> void error(TError error,
                                                            AsyncSupplier<TResult,TError> result,
                                                            Consumer<Pair<TResult,TError>> ondone)

Shortcut to transfer an error to ondone if it is not null, and to the AsyncWork.

error

public static <TResult,TError extends Exception> AsyncSupplier<TResult,TError> error(TError error,
                                                                                     Consumer<Pair<TResult,TError>> ondone)

Shortcut to transfer an error to ondone if it is not null, and create an AsyncWork with this error.

success

public static <TResult,TError extends Exception> void success(TResult res,
                                                              AsyncSupplier<TResult,TError> result,
                                                              Consumer<Pair<TResult,TError>> ondone)

Shortcut to transfer a result to ondone if it is not null, and to the AsyncWork.

success

public static <TResult,TError extends Exception> AsyncSupplier<TResult,TError> success(TResult result,
                                                                                       Consumer<Pair<TResult,TError>> ondone)

Shortcut to transfer a result to ondone if it is not null, and create an AsyncWork with this result.

notSuccess

public static <TResult,TError extends Exception> void notSuccess(IAsync<TError> sp,
                                                                 AsyncSupplier<TResult,TError> result,
                                                                 Consumer<Pair<TResult,TError>> ondone)

Shortcut to transfer error or cancellation.

getSizeSync

public static long getSizeSync(IO.Readable.Seekable io)
                        throws IOException

Get the size by seeking at the end if not an instanceof IO.KnownSize.

Throws:: IOException

Class IOUtil

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

readFully

readFully

readFully

readFully

readFullyKnownSize

readFullyKnownSize

readFullySync

readFullyAsync

readFullyAsync

readFullyAsync

readFullyAsync

readAsyncUsingSync

readAsyncUsingSync

readFullyAsyncUsingSync

readFullyAsyncUsingSync

skipSyncByReading

skipAsyncUsingSync

skipAsyncByReading

toTempFile

toTempFile

readSyncUsingAsync

readSyncUsingAsync

readFullySyncUsingAsync

readFullySyncUsingAsync

skipSyncUsingAsync

writeSyncUsingAsync

writeSyncUsingAsync

writeAsyncUsingSync

writeAsyncUsingSync

readFullyAsString

readFullyAsStringSync

readFullyAsStringSync

readFullyAsStringSync

readFullyAsStringSync

readFullyAsStringSync

seekAsyncUsingSync

seekSyncUsingAsync

setSizeAsyncUsingSync

copy

copy

copy

closeAsync

readFully

getUnderlyingTaskManager

getUnderlyingIO

listenOnDone

listenOnDone

listenOnDone

listenOnDone

errorConsumer

error

error

success

success

notSuccess

getSizeSync