net.lecousin.framework.io

Class FragmentedSubIO

java.lang.Object

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

net.lecousin.framework.io.FragmentedSubIO

All Implemented Interfaces:

AutoCloseable, IO, IO.KnownSize, IO.PositionKnown, IO.Seekable, AsyncCloseable<IOException>, CloseableListenable, IConcurrentCloseable<IOException>

Direct Known Subclasses:

FragmentedSubIO.Readable

public abstract class FragmentedSubIO
extends ConcurrentCloseable<IOException>
implements IO.KnownSize, IO.Seekable

A fragmented sub-IO allows to specify a list of fragments inside a seekable IO, and does like those fragments are a contiguous IO. TODO improve perf by storing the fragment containing the current position ?

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	FragmentedSubIO.Readable Readable fragmented IO.
static class	FragmentedSubIO.ReadWrite Readable and Writable fragmented IO.

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

IO.Seekable.SeekType

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 boolean	closeParentIOOnClose
protected String	description
protected List<RangeLong>	fragments
protected IO.Seekable	io
protected long	pos
protected long	size

Constructor Summary

Constructors

Constructor and Description
FragmentedSubIO(IO.Seekable io, List<RangeLong> fragments, boolean closeParentIOOnClose, String description) Constructor.

Method Summary

Modifier and Type	Method and Description
protected IAsync<IOException>	canStartWriting()
protected void	closeResources(Async<IOException> ondone)
protected IAsync<IOException>	closeUnderlyingResources()
long	getPosition() Return the current position.
byte	getPriority() Return the priority.
AsyncSupplier<Long,IOException>	getSizeAsync() Asynchronous operation to get the size of the IO.
long	getSizeSync() Synchronous operation to get the size of the IO.
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 AsyncSupplier<Integer,IOException>	readAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
protected int	readFullySync(long pos, ByteBuffer buffer)
protected int	readSync(long pos, ByteBuffer buffer)
AsyncSupplier<Long,IOException>	seekAsync(IO.Seekable.SeekType type, long move, Consumer<Pair<Long,IOException>> ondone) Returns the new position.
long	seekSync(IO.Seekable.SeekType type, long move) Returns the new position.
void	setPriority(byte priority) Set the priority of asynchronous operations.
protected AsyncSupplier<Long,IOException>	skipAsync(long n, Consumer<Pair<Long,IOException>> ondone)
protected long	skipSync(long n)
protected void	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>	writeAsync(long pos, ByteBuffer buffer, Consumer<Pair<Integer,IOException>> ondone)
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.Seekable

seekAsync

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

io

protected IO.Seekable io

fragments

protected List<RangeLong> fragments

pos

protected long pos

size

protected long size

closeParentIOOnClose

protected boolean closeParentIOOnClose

description

protected String description

Constructor Detail

FragmentedSubIO

public FragmentedSubIO(IO.Seekable io,
                       List<RangeLong> fragments,
                       boolean closeParentIOOnClose,
                       String description)

Constructor.

Method Detail

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>

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

getTaskManager

public TaskManager getTaskManager()

Description copied from interface: IO

Return the TaskManager used for asynchronous operations.

Specified by:

getTaskManager in interface IO

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

getPosition

public long getPosition()

Description copied from interface: IO.PositionKnown

Return the current position.

Specified by:

getPosition in interface IO.PositionKnown

getSizeSync

public long getSizeSync()

Description copied from interface: IO.KnownSize

Synchronous operation to get the size of the IO.

Specified by:

getSizeSync in interface IO.KnownSize

getSizeAsync

public AsyncSupplier<Long,IOException> getSizeAsync()

Description copied from interface: IO.KnownSize

Asynchronous operation to get the size of the IO.

Specified by:

getSizeAsync in interface IO.KnownSize

readAsync

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

readSync

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

Throws:

IOException

readFullySync

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

Throws:

IOException

seekSync

public long seekSync(IO.Seekable.SeekType type,
                     long move)

Description copied from interface: IO.Seekable

Returns the new position. The implementation must not allow to seek after the end of the file, the method setSize should be used instead. It must accept seeking beyond the end, but position at the end, and accept seeking before the beginning, but position at the beginning.

Specified by:

seekSync in interface IO.Seekable

skipSync

protected long skipSync(long n)

seekAsync

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

Description copied from interface: IO.Seekable

Returns the new position. The implementation must not allow to seek after the end of the file, the method setSize should be used instead. It must accept seeking beyond the end, but position at the end, and accept seeking before the beginning, but position at the beginning.

Specified by:

seekAsync in interface IO.Seekable

skipAsync

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

canStartWriting

protected IAsync<IOException> canStartWriting()

writeSync

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

Throws:

IOException

writeAsync

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

writeAsync

protected void writeAsync(Iterator<RangeLong> it,
                          RangeLong r,
                          long p,
                          int done,
                          long pos,
                          ByteBuffer buffer,
                          Consumer<Pair<Integer,IOException>> ondone,
                          AsyncSupplier<Integer,IOException> sp)