Uses of Class
net.lecousin.framework.util.Pair

Packages that use Pair

Package	Description
net.lecousin.framework.application.libraries.artifacts	Libraries management using group id, artifact id and version.
net.lecousin.framework.collections	Implementations of collections.
net.lecousin.framework.concurrent	Multi-threading framework.
net.lecousin.framework.concurrent.tasks.drives	Tasks on files or directories.
net.lecousin.framework.io	New java Input/Output model adding more flexibility and asynchronous operations.
net.lecousin.framework.io.buffering	IO with bufferization.
net.lecousin.framework.io.out2in	Implementations of IO.OutputToInput.
net.lecousin.framework.io.serialization	Serialization and deserialization framework.
net.lecousin.framework.io.util	Utility classes for IO.
net.lecousin.framework.math	Utility classes.
net.lecousin.framework.properties	Utility classes for properties.
net.lecousin.framework.util	Utility classes.
net.lecousin.framework.xml	XML Parsing and generation.
net.lecousin.framework.xml.dom	Simple (partial) DOM implementation.
net.lecousin.framework.xml.serialization	XML serialization and deserialization.

Uses of Pair in net.lecousin.framework.application.libraries.artifacts

Methods in net.lecousin.framework.application.libraries.artifacts that return types with arguments of type Pair

Modifier and Type	Method and Description
List<Pair<String,String>>	LibraryDescriptor.Dependency.getExcludedDependencies() Return a list of dependencies that should be ignored from this dependency, with pairs of groupId/artifactId.
List<Pair<String,String>>	LibraryDescriptor.Dependency.From.getExcludedDependencies()

Uses of Pair in net.lecousin.framework.collections

Fields in net.lecousin.framework.collections with type parameters of type Pair

Modifier and Type	Field and Description
protected LinkedList<Pair<CollectionListener<T>,Task<Void,NoException>>>	CollectionListener.Keep.listeners

Uses of Pair in net.lecousin.framework.concurrent

Method parameters in net.lecousin.framework.concurrent with type arguments of type Pair

Modifier and Type	Method and Description
void	DrivesTaskManager.DrivesProvider.provide(Consumer<Pair<Object,List<File>>> onNewDrive, Consumer<Pair<Object,List<File>>> onDriveRemoved, Consumer<Pair<Object,File>> onNewPartition, Consumer<Pair<Object,File>> onPartitionRemoved) Register listeners.
void	DrivesTaskManager.DrivesProvider.provide(Consumer<Pair<Object,List<File>>> onNewDrive, Consumer<Pair<Object,List<File>>> onDriveRemoved, Consumer<Pair<Object,File>> onNewPartition, Consumer<Pair<Object,File>> onPartitionRemoved) Register listeners.
void	DrivesTaskManager.DrivesProvider.provide(Consumer<Pair<Object,List<File>>> onNewDrive, Consumer<Pair<Object,List<File>>> onDriveRemoved, Consumer<Pair<Object,File>> onNewPartition, Consumer<Pair<Object,File>> onPartitionRemoved) Register listeners.
void	DrivesTaskManager.DrivesProvider.provide(Consumer<Pair<Object,List<File>>> onNewDrive, Consumer<Pair<Object,List<File>>> onDriveRemoved, Consumer<Pair<Object,File>> onNewPartition, Consumer<Pair<Object,File>> onPartitionRemoved) Register listeners.

Constructor parameters in net.lecousin.framework.concurrent with type arguments of type Pair

Constructor and Description
Cpu(String description, byte priority, Consumer<Pair<T,TError>> ondone) Constructor.
FromRunnable(Runnable runnable, String description, byte priority, Consumer<Pair<Void,NoException>> ondone) Constructor.
FromSupplierThrows(String description, byte priority, Consumer<Pair<T,TError>> ondone, Runnables.SupplierThrows<T,TError> supplier) Constructor.
OnFile(File file, String description, byte priority, Consumer<Pair<T,TError>> ondone) Constructor.
OnFile(TaskManager manager, String description, byte priority, Consumer<Pair<T,TError>> ondone) Constructor.
Parameter(File file, String description, byte priority, Consumer<Pair<TResult,TError>> ondone) Constructor.
Parameter(String description, byte priority, Consumer<Pair<TResult,TError>> ondone) Constructor.
Parameter(TaskManager tm, String description, byte priority, Consumer<Pair<TResult,TError>> ondone) Constructor.
Task(Object resource, String description, byte priority, Consumer<Pair<T,TError>> ondone) Constructor.
Task(TaskManager manager, String description, byte priority, Consumer<Pair<T,TError>> ondone) Constructor.

Uses of Pair in net.lecousin.framework.concurrent.tasks.drives

Method parameters in net.lecousin.framework.concurrent.tasks.drives with type arguments of type Pair

Modifier and Type	Method and Description
Task<Integer,IOException>	FileAccess.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
Task<Integer,IOException>	FileAccess.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
Task<Long,IOException>	FileAccess.seekAsync(IO.Seekable.SeekType type, long move, boolean allowAfterEnd, Consumer<Pair<Long,IOException>> ondone)
Task<Long,IOException>	FileAccess.skipAsync(long move, Consumer<Pair<Long,IOException>> ondone)
Task<Integer,IOException>	FileAccess.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)

Uses of Pair in net.lecousin.framework.io

Method parameters in net.lecousin.framework.io with type arguments of type Pair

Modifier and Type	Method and Description
static <TResult,TError extends Exception> void	IOUtil.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>	IOUtil.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>	IOUtil.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 <T> void	IOUtil.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	IOUtil.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	IOUtil.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	IOUtil.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	IOUtil.notSuccess(IAsync<TError> sp, AsyncSupplier<TResult,TError> result, Consumer<Pair<TResult,TError>> ondone) Shortcut to transfer error or cancellation.
protected AsyncSupplier<Integer,IOException>	SubIO.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.Readable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.Readable.Seekable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.ReadWrite.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	PositionKnownWrapper.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	PositionKnownWrapper.Readable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	PositionKnownWrapper.Readable.Buffered.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	LinkedIO.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	LinkedIO.Readable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IOFromInputStream.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IO.Readable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) Asynchronous read operation.
AsyncSupplier<Integer,IOException>	FragmentedSubIO.Readable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	FileIO.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.ReadOnly.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.ReadWrite.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	SubIO.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.Readable.Seekable.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.ReadWrite.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	LinkedIO.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	LinkedIO.Readable.Seekable.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IO.Readable.Seekable.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) Same as IO.Readable.readAsync(ByteBuffer, Consumer) but read at the given position.
protected AsyncSupplier<Integer,IOException>	FragmentedSubIO.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FragmentedSubIO.Readable.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	FileIO.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.ReadOnly.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.ReadWrite.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
static Task<Integer,IOException>	IOUtil.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>	IOUtil.readAsyncUsingSync(IO.Readable io, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) Implement an asynchronous read using a task calling the synchronous one.
protected AsyncSupplier<Integer,IOException>	SubIO.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.Readable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.Readable.Seekable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.ReadWrite.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	PositionKnownWrapper.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	PositionKnownWrapper.Readable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	PositionKnownWrapper.Readable.Buffered.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	LinkedIO.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	LinkedIO.Readable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IOFromInputStream.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IO.Readable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) Asynchronous read operation to fully fill the given buffer.
AsyncSupplier<Integer,IOException>	FragmentedSubIO.Readable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	FileIO.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.ReadOnly.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.ReadWrite.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
static AsyncSupplier<Integer,IOException>	IOUtil.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>	IOUtil.readFullyAsync(IO.Readable io, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) Fill the remaining bytes of the given buffer asynchronously.
static AsyncSupplier<Integer,IOException>	IOUtil.readFullyAsync(IO.Readable io, ByteBuffer buffer, int done, Consumer<Pair<Integer,IOException>> ondone) Fill the remaining bytes of the given buffer asynchronously.
protected AsyncSupplier<Integer,IOException>	SubIO.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.Readable.Seekable.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.ReadWrite.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	LinkedIO.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	LinkedIO.Readable.Seekable.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IO.Readable.Seekable.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) Same as IO.Readable.readFullyAsync(ByteBuffer, Consumer) but read at the given position.
AsyncSupplier<Integer,IOException>	FragmentedSubIO.Readable.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	FileIO.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.ReadOnly.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.ReadWrite.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
static Task<Integer,IOException>	IOUtil.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>	IOUtil.readFullyAsyncUsingSync(IO.Readable io, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) Implement an asynchronous read using a task calling the synchronous one.
AsyncSupplier<Integer,IOException>	SubIO.Readable.Seekable.Buffered.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	PositionKnownWrapper.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	PositionKnownWrapper.Readable.Buffered.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	LinkedIO.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	LinkedIO.Readable.Buffered.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	LinkedIO.Readable.Seekable.Buffered.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IO.Readable.Buffered.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) While readAsync methods are supposed to do the job in a separate thread, this method fills the given buffer synchronously if enough data is already buffered, else it finishes asynchronously.
AsyncSupplier<ByteBuffer,IOException>	SubIO.Readable.Seekable.Buffered.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
protected AsyncSupplier<ByteBuffer,IOException>	PositionKnownWrapper.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	PositionKnownWrapper.Readable.Buffered.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
protected AsyncSupplier<ByteBuffer,IOException>	LinkedIO.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	LinkedIO.Readable.Buffered.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	LinkedIO.Readable.Seekable.Buffered.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	IO.Readable.Buffered.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone) Retrieve a buffer of bytes in the most efficient way depending on the implementation of Buffered. This method is similar to readAsync, it reads some bytes that are immediately available with a minimum of operations.
protected AsyncSupplier<Long,IOException>	SubIO.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	SubIO.Readable.Seekable.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	SubIO.Writable.Seekable.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	SubIO.ReadWrite.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
protected AsyncSupplier<Long,IOException>	LinkedIO.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	LinkedIO.Readable.Seekable.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	IO.Seekable.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone) Returns the new position.
AsyncSupplier<Long,IOException>	FragmentedSubIO.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
protected AsyncSupplier<Long,IOException>	FileIO.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	FileIO.ReadOnly.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	FileIO.WriteOnly.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	FileIO.ReadWrite.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
static Task<Long,IOException>	IOUtil.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.
AsyncSupplier<Long,IOException>	SubIO.Readable.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	SubIO.Readable.Seekable.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	SubIO.ReadWrite.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
protected AsyncSupplier<Long,IOException>	PositionKnownWrapper.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	PositionKnownWrapper.Readable.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	PositionKnownWrapper.Readable.Buffered.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
protected AsyncSupplier<Long,IOException>	LinkedIO.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	LinkedIO.Readable.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	IOFromInputStream.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	IO.Readable.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone) Returns the number of bytes skipped.
protected AsyncSupplier<Long,IOException>	FragmentedSubIO.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	FragmentedSubIO.Readable.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
protected AsyncSupplier<Long,IOException>	FileIO.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	FileIO.ReadOnly.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	FileIO.ReadWrite.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
static AsyncSupplier<Long,IOException>	IOUtil.skipAsyncByReading(IO.Readable io, long n, Consumer<Pair<Long,IOException>> ondone) Implement an asynchronous skip using readAsync.
static AsyncSupplier<Long,IOException>	IOUtil.skipAsyncUsingSync(IO.Readable io, long n, Consumer<Pair<Long,IOException>> ondone) Implement an asynchronous skip using a task calling a synchronous skip.
static <TResult,TError extends Exception> void	IOUtil.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>	IOUtil.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.
protected AsyncSupplier<Integer,IOException>	SubIO.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.Writable.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.Writable.Seekable.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.ReadWrite.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	LinkedIO.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	LinkedIO.ReadWrite.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IOFromOutputStream.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IO.Writable.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) Write asynchronously all bytes available in the given buffer at the current position.
AsyncSupplier<Integer,IOException>	FragmentedSubIO.ReadWrite.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	FileIO.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.WriteOnly.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.ReadWrite.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected void	FragmentedSubIO.writeAsync(Iterator<RangeLong> it, RangeLong r, long p, int done, long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone, AsyncSupplier<Integer,IOException> sp)
protected AsyncSupplier<Integer,IOException>	SubIO.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.Writable.Seekable.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SubIO.ReadWrite.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	LinkedIO.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	LinkedIO.ReadWrite.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IO.Writable.Seekable.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) Same as IO.Writable.writeAsync(ByteBuffer, Consumer) but at the given position.
protected AsyncSupplier<Integer,IOException>	FragmentedSubIO.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FragmentedSubIO.ReadWrite.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	FileIO.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.WriteOnly.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	FileIO.ReadWrite.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
static Task<Integer,IOException>	IOUtil.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>	IOUtil.writeAsyncUsingSync(IO.Writable io, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) Implement an asynchronous write using a task calling a synchronous write.

Constructor parameters in net.lecousin.framework.io with type arguments of type Pair

Constructor and Description
RecursiveAsyncSupplierListener(IOUtil.RecursiveAsyncSupplierListener.OnSuccess<T> onSuccess, IAsync<IOException> onErrorOrCancel, Consumer<Pair<T2,IOException>> ondone) Constructor.

Uses of Pair in net.lecousin.framework.io.buffering

Method parameters in net.lecousin.framework.io.buffering with type arguments of type Pair

Modifier and Type	Method and Description
AsyncSupplier<Integer,IOException>	TwoBuffersIO.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SingleBufferReadable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SimpleBufferedReadable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ReadableToSeekable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	PreBufferedReadable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	MemoryIO.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IOInMemoryOrFile.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteBuffersIO.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteArrayIO.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	BufferedIO.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	TwoBuffersIO.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ReadableToSeekable.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	MemoryIO.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IOInMemoryOrFile.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteBuffersIO.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteArrayIO.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	BufferedIO.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	TwoBuffersIO.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SingleBufferReadable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SimpleBufferedReadable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ReadableToSeekable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	PreBufferedReadable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	MemoryIO.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IOInMemoryOrFile.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteBuffersIO.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteArrayIO.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	BufferedIO.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	TwoBuffersIO.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ReadableToSeekable.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	MemoryIO.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IOInMemoryOrFile.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteBuffersIO.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteArrayIO.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	BufferedIO.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	TwoBuffersIO.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SingleBufferReadable.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SimpleBufferedReadable.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ReadableToSeekable.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	PreBufferedReadable.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	MemoryIO.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteBuffersIO.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteArrayIO.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	BufferedIO.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	BufferedIO.readFullySyncIfPossible(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone) While readAsync methods are supposed to do the job in a separate thread, this method fills the given buffer synchronously if enough data is already buffered, else it finishes asynchronously.
AsyncSupplier<ByteBuffer,IOException>	TwoBuffersIO.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	SingleBufferReadable.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	SimpleBufferedReadable.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	ReadableToSeekable.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	PreBufferedReadable.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	MemoryIO.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	ByteBuffersIO.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	ByteArrayIO.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	BufferedIO.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<Long,IOException>	TwoBuffersIO.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	TwoBuffersIO.DeterminedSize.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	ReadableToSeekable.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	MemoryIO.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	IOInMemoryOrFile.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	ByteBuffersIO.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	ByteArrayIO.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	BufferedIO.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	TwoBuffersIO.skipAsync(long skip, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	SingleBufferReadable.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	SimpleBufferedReadable.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	ReadableToSeekable.skipAsync(long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	PreBufferedReadable.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	MemoryIO.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	IOInMemoryOrFile.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	ByteBuffersIO.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	ByteArrayIO.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	BufferedIO.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Integer,IOException>	SimpleBufferedWritable.writeAsync(ByteBuffer buf, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	MemoryIO.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IOInMemoryOrFile.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteBuffersIO.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteArrayIO.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	BufferedIO.ReadWrite.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	MemoryIO.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	IOInMemoryOrFile.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ByteArrayIO.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	BufferedIO.ReadWrite.writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)

Uses of Pair in net.lecousin.framework.io.out2in

Method parameters in net.lecousin.framework.io.out2in with type arguments of type Pair

Modifier and Type	Method and Description
AsyncSupplier<Integer,IOException>	OutputToInputBuffers.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	OutputToInput.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	OutputToInput.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	OutputToInputBuffers.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	OutputToInput.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	OutputToInput.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	OutputToInputBuffers.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	OutputToInputBuffers.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<Long,IOException>	OutputToInput.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	OutputToInputBuffers.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	OutputToInput.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Integer,IOException>	OutputToInputBuffers.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	OutputToInput.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)

Uses of Pair in net.lecousin.framework.io.serialization

Methods in net.lecousin.framework.io.serialization that return types with arguments of type Pair

Modifier and Type	Method and Description
protected AsyncSupplier<Pair<Object,Boolean>,SerializationException>	AbstractDeserializer.deserializeCollectionAttributeValueElement(SerializationContext.CollectionContext context, int elementIndex, String colPath, List<SerializationRule> rules) Return the element with true if an element is found, or null with false if the end of the collection has been reached.
protected abstract AsyncSupplier<Pair<Object,Boolean>,SerializationException>	AbstractDeserializer.deserializeCollectionValueElement(SerializationContext.CollectionContext context, int elementIndex, String colPath, List<SerializationRule> rules) Return the element (possibly null) with true if an element is found, or null with false if the end of the collection has been reached.

Uses of Pair in net.lecousin.framework.io.util

Method parameters in net.lecousin.framework.io.util with type arguments of type Pair

Modifier and Type	Method and Description
AsyncSupplier<Integer,IOException>	ReadableSeekableToDeterminedSize.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	NonBufferedReadableIOAsBuffered.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	EmptyReadable.readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ReadableSeekableToDeterminedSize.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	EmptyReadable.readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ReadableSeekableToDeterminedSize.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	NonBufferedReadableIOAsBuffered.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	EmptyReadable.readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	ReadableSeekableToDeterminedSize.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	EmptyReadable.readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	NonBufferedReadableIOAsBuffered.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<Integer,IOException>	EmptyReadable.readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	NonBufferedReadableIOAsBuffered.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<ByteBuffer,IOException>	EmptyReadable.readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
AsyncSupplier<Long,IOException>	ReadableSeekableToDeterminedSize.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	EmptyReadable.seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	ReadableSeekableToDeterminedSize.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	NonBufferedReadableIOAsBuffered.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Long,IOException>	EmptyReadable.skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
AsyncSupplier<Integer,IOException>	BroadcastIO.writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)

Uses of Pair in net.lecousin.framework.math

Methods in net.lecousin.framework.math that return Pair

Modifier and Type	Method and Description
Pair<RangeBigInteger,RangeBigInteger>	RangeBigInteger.removeIntersect(RangeBigInteger o) Remove the intersection between this range and the given range, and return the range before and the range after the intersection.
Pair<RangeInteger,RangeInteger>	RangeInteger.removeIntersect(RangeInteger o) Remove the intersection between this range and the given range, and return the range before and the range after the intersection.
Pair<RangeLong,RangeLong>	RangeLong.removeIntersect(RangeLong o) Remove the intersection between this range and the given range, and return the range before and the range after the intersection.

Uses of Pair in net.lecousin.framework.properties

Methods in net.lecousin.framework.properties that return types with arguments of type Pair

Modifier and Type	Method and Description
Collection<Pair<ILocalizableString,Object>>	PropertiesContainer.getProperties() Return the properties of this object.

Uses of Pair in net.lecousin.framework.util

Subclasses of Pair in net.lecousin.framework.util

Modifier and Type	Class and Description
static class	Pair.Serializable<T1 extends Serializable,T2 extends Serializable> Serializable Pair.

Uses of Pair in net.lecousin.framework.xml

Fields in net.lecousin.framework.xml with type parameters of type Pair

Modifier and Type	Field and Description
List<Pair<UnprotectedStringBuffer,UnprotectedStringBuffer>>	XMLStreamEvents.ElementContext.namespaces List of pair prefix/uri.

Uses of Pair in net.lecousin.framework.xml.dom

Fields in net.lecousin.framework.xml.dom with type parameters of type Pair

Modifier and Type	Field and Description
protected Map<String,Pair<Object,UserDataHandler>>	XMLNode.userData

Uses of Pair in net.lecousin.framework.xml.serialization

Methods in net.lecousin.framework.xml.serialization that return types with arguments of type Pair

Modifier and Type	Method and Description
protected AsyncSupplier<Pair<Object,Boolean>,SerializationException>	XMLDeserializer.deserializeCollectionAttributeValueElement(SerializationContext.CollectionContext context, int elementIndex, String colPath, List<SerializationRule> rules)
protected AsyncSupplier<Pair<Object,Boolean>,SerializationException>	XMLDeserializer.deserializeCollectionValueElement(SerializationContext.CollectionContext context, int elementIndex, String colPath, List<SerializationRule> rules)