net.lecousin.framework.io

Class LinkedIO

java.lang.Object

net.lecousin.framework.util.ConcurrentCloseable<IOException>

net.lecousin.framework.io.LinkedIO

All Implemented Interfaces:

AutoCloseable, IO, AsyncCloseable<IOException>, CloseableListenable, IConcurrentCloseable<IOException>

Direct Known Subclasses:

LinkedIO.Readable

public abstract class LinkedIO
extends ConcurrentCloseable<IOException>
implements IO

Make several IOs as a single one.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	LinkedIO.Readable Linked Readable IO.
static class	LinkedIO.ReadWrite Linked Readable and Writable IO.

Nested classes/interfaces inherited from interface net.lecousin.framework.io.IO

IO.KnownSize, IO.OperationType, IO.OutputToInput, IO.PositionKnown, IO.ReadableByteStream, IO.Resizable, IO.Seekable, IO.Writable, IO.WritableByteStream, IO.WriterAsync

Nested classes/interfaces inherited from interface net.lecousin.framework.util.CloseableListenable

CloseableListenable.Impl

Field Summary

Fields

Modifier and Type	Field and Description
protected String	description
protected int	ioIndex
protected ArrayList<IO>	ios
protected long	pos
protected long	posInIO
protected ArrayList<Long>	sizes

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	LinkedIO(String description, IO[] ios)

Method Summary

Modifier and Type	Method and Description
protected IAsync<IOException>	canStartReading()
protected IAsync<IOException>	canStartWriting()
protected void	closeResources(Async<IOException> ondone)
protected IAsync<IOException>	closeUnderlyingResources()
protected long	getPosition()
byte	getPriority() Return the priority.
protected AsyncSupplier<Long,IOException>	getSizeAsync()
protected long	getSizeSync()
String	getSourceDescription() Describe the IO, which can be used for logging or debugging purposes.
TaskManager	getTaskManager() Return the TaskManager used for asynchronous operations.
IO	getWrappedIO() If this IO is wrapping another one (such as adding Buffered capabilities), this method returns it, or null if it does not wrap another IO.
protected abstract void	nextIOAsync(Runnable ondone, IAsync<IOException> onerror, Consumer rp)
protected void	nextIOAsyncSeekable(Runnable ondone, IAsync<IOException> onerror, Consumer rp)
protected void	nextIOAsyncStream(Runnable ondone)
protected abstract void	nextIOSync()
protected void	nextIOSyncSeekable()
protected void	nextIOSyncStream()
protected abstract void	previousIOAsync(Runnable ondone, IAsync<IOException> onerror, Consumer rp)
protected void	previousIOAsyncSeekable(Runnable ondone, IAsync<IOException> onerror, Consumer rp)
protected void	previousIOAsyncStream(Runnable ondone)
protected abstract void	previousIOSync()
protected void	previousIOSyncSeekable()
protected void	previousIOSyncStream()
protected int	read()
protected int	read(byte[] buf, int off, int len)
protected int	readAsync()
protected AsyncSupplier<Integer,IOException>	readAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected int	readFully(byte[] buffer)
protected AsyncSupplier<Integer,IOException>	readFullyAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	readFullyAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected int	readFullySync(ByteBuffer buffer)
protected int	readFullySync(long pos, ByteBuffer buffer)
protected AsyncSupplier<Integer,IOException>	readFullySyncIfPossible(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected ByteBuffer	readNextBuffer()
protected AsyncSupplier<ByteBuffer,IOException>	readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)
protected int	readSync(ByteBuffer buffer)
protected int	readSync(long pos, ByteBuffer buffer)
protected AsyncSupplier<Long,IOException>	seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone)
protected long	seekSync(IO.Seekable.SeekType type, long move)
void	setPriority(byte priority) Set the priority of asynchronous operations.
protected int	skip(int n)
protected AsyncSupplier<Long,IOException>	skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
protected long	skipSync(long n)
protected AsyncSupplier<Integer,IOException>	writeAsync(ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected AsyncSupplier<Integer,IOException>	writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected int	writeSync(ByteBuffer buffer)
protected int	writeSync(long pos, ByteBuffer buffer)

Methods inherited from class net.lecousin.framework.util.ConcurrentCloseable

addCloseListener, addCloseListener, close, closeAsync, isClosed, isClosing, lockClose, operation, operation, removeCloseListener, removeCloseListener, unlockClose

Methods inherited from class java.lang.Object

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

Methods inherited from interface net.lecousin.framework.io.IO

cancelClosed, error, errorCancelled

Methods inherited from interface net.lecousin.framework.util.IConcurrentCloseable

lockClose, unlockClose

Methods inherited from interface java.lang.AutoCloseable

close

Methods inherited from interface net.lecousin.framework.util.AsyncCloseable

closeAfter, closeAsync

Methods inherited from interface net.lecousin.framework.util.CloseableListenable

addCloseListener, addCloseListener, close, isClosed, removeCloseListener, removeCloseListener

Field Detail

description

protected String description

ios

protected ArrayList<IO> ios

sizes

protected ArrayList<Long> sizes

ioIndex

protected int ioIndex

pos

protected long pos

posInIO

protected long posInIO

Constructor Detail

LinkedIO

protected LinkedIO(String description,
                   IO[] ios)

Method Detail

getPriority

public byte getPriority()

Description copied from class: ConcurrentCloseable

Return the priority.

Specified by:

getPriority in interface IO

Specified by:

getPriority in class ConcurrentCloseable<IOException>

setPriority

public void setPriority(byte priority)

Description copied from interface: IO

Set the priority of asynchronous operations.

Specified by:

setPriority in interface IO

getSourceDescription

public String getSourceDescription()

Description copied from interface: IO

Describe the IO, which can be used for logging or debugging purposes.

Specified by:

getSourceDescription in interface IO

getTaskManager

public TaskManager getTaskManager()

Description copied from interface: IO

Return the TaskManager used for asynchronous operations.

Specified by:

getTaskManager in interface IO

getWrappedIO

public IO getWrappedIO()

Description copied from interface: IO

If this IO is wrapping another one (such as adding Buffered capabilities), this method returns it, or null if it does not wrap another IO.

Specified by:

getWrappedIO in interface IO

closeUnderlyingResources

protected IAsync<IOException> closeUnderlyingResources()

Specified by:

closeUnderlyingResources in class ConcurrentCloseable<IOException>

closeResources

protected void closeResources(Async<IOException> ondone)

Specified by:

closeResources in class ConcurrentCloseable<IOException>

nextIOSync

protected abstract void nextIOSync()
                            throws IOException

Throws:

IOException

previousIOSync

protected abstract void previousIOSync()
                                throws IOException

Throws:

IOException

nextIOAsync

protected abstract void nextIOAsync(Runnable ondone,
                                    IAsync<IOException> onerror,
                                    Consumer rp)

previousIOAsync

protected abstract void previousIOAsync(Runnable ondone,
                                        IAsync<IOException> onerror,
                                        Consumer rp)

nextIOSyncStream

protected void nextIOSyncStream()

previousIOSyncStream

protected void previousIOSyncStream()

nextIOAsyncStream

protected void nextIOAsyncStream(Runnable ondone)

previousIOAsyncStream

protected void previousIOAsyncStream(Runnable ondone)

nextIOSyncSeekable

protected void nextIOSyncSeekable()
                           throws IOException

Throws:

IOException

previousIOSyncSeekable

protected void previousIOSyncSeekable()
                               throws IOException

Throws:

IOException

nextIOAsyncSeekable

protected void nextIOAsyncSeekable(Runnable ondone,
                                   IAsync<IOException> onerror,
                                   Consumer rp)

previousIOAsyncSeekable

protected void previousIOAsyncSeekable(Runnable ondone,
                                       IAsync<IOException> onerror,
                                       Consumer rp)

readSync

protected int readSync(ByteBuffer buffer)
                throws IOException

Throws:

IOException

readFullySync

protected int readFullySync(ByteBuffer buffer)
                     throws IOException

Throws:

IOException

readFullySyncIfPossible

protected AsyncSupplier<Integer,IOException> readFullySyncIfPossible(ByteBuffer buffer,
                                                                     Consumer<Pair<Integer,IOException>> ondone)

readAsync

protected int readAsync()
                 throws IOException

Throws:

IOException

readAsync

protected AsyncSupplier<Integer,IOException> readAsync(ByteBuffer buffer,
                                                       Consumer<Pair<Integer,IOException>> ondone)

readFullyAsync

protected AsyncSupplier<Integer,IOException> readFullyAsync(ByteBuffer buffer,
                                                            Consumer<Pair<Integer,IOException>> ondone)

readNextBufferAsync

protected AsyncSupplier<ByteBuffer,IOException> readNextBufferAsync(Consumer<Pair<ByteBuffer,IOException>> ondone)

readNextBuffer

protected ByteBuffer readNextBuffer()
                             throws IOException

Throws:

IOException

skipSync

protected long skipSync(long n)
                 throws IOException

Throws:

IOException

skipAsync

protected AsyncSupplier<Long,IOException> skipAsync(long n,
                                                    Consumer<Pair<Long,IOException>> ondone)

read

protected int read()
            throws IOException

Throws:

IOException

read

protected int read(byte[] buf,
                   int off,
                   int len)
            throws IOException

Throws:

IOException

readFully

protected int readFully(byte[] buffer)
                 throws IOException

Throws:

IOException

skip

protected int skip(int n)
            throws IOException

Throws:

IOException

canStartReading

protected IAsync<IOException> canStartReading()

canStartWriting

protected IAsync<IOException> canStartWriting()

getSizeSync

protected long getSizeSync()
                    throws IOException

Throws:

IOException

getSizeAsync

protected AsyncSupplier<Long,IOException> getSizeAsync()

getPosition

protected long getPosition()

seekSync

protected long seekSync(IO.Seekable.SeekType type,
                        long move)
                 throws IOException

Throws:

IOException

seekAsync

protected AsyncSupplier<Long,IOException> seekAsync(IO.Seekable.SeekType type,
                                                    long move,
                                                    Consumer<Pair<Long,IOException>> ondone)

readSync

protected int readSync(long pos,
                       ByteBuffer buffer)
                throws IOException

Throws:

IOException

readAsync

protected AsyncSupplier<Integer,IOException> readAsync(long pos,
                                                       ByteBuffer buffer,
                                                       Consumer<Pair<Integer,IOException>> ondone)

readFullySync

protected int readFullySync(long pos,
                            ByteBuffer buffer)
                     throws IOException

Throws:

IOException

readFullyAsync

protected AsyncSupplier<Integer,IOException> readFullyAsync(long pos,
                                                            ByteBuffer buffer,
                                                            Consumer<Pair<Integer,IOException>> ondone)

writeSync

protected int writeSync(ByteBuffer buffer)
                 throws IOException

Throws:

IOException

writeSync

protected int writeSync(long pos,
                        ByteBuffer buffer)
                 throws IOException

Throws:

IOException

writeAsync

protected AsyncSupplier<Integer,IOException> writeAsync(ByteBuffer buffer,
                                                        Consumer<Pair<Integer,IOException>> ondone)

writeAsync

protected AsyncSupplier<Integer,IOException> writeAsync(long pos,
                                                        ByteBuffer buffer,
                                                        Consumer<Pair<Integer,IOException>> ondone)