com.google.cloud.storage.contrib.nio

Class SeekableByteChannelPrefetcher

java.lang.Object

com.google.cloud.storage.contrib.nio.SeekableByteChannelPrefetcher

All Implemented Interfaces:

Closeable, AutoCloseable, ByteChannel, Channel, ReadableByteChannel, SeekableByteChannel, WritableByteChannel

public final class SeekableByteChannelPrefetcher
extends Object
implements SeekableByteChannel

SeekableByteChannelPrefetcher wraps an existing SeekableByteChannel to add prefetching. The prefetching is done on a different thread, so you can write simple code that repeatedly calls read() to get data, processes it, and then calls read again -- and yet this simple code overlaps computation and communication for you. (Of course this is only worthwhile if the underlying SeekableByteChannel doesn't already implement prefetching).

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SeekableByteChannelPrefetcher.Statistics

Method Summary

Modifier and Type	Method and Description
static SeekableByteChannel	addPrefetcher(int bufferSizeMB, SeekableByteChannel channel) Wraps the provided SeekableByteChannel within a SeekableByteChannelPrefetcher, using the provided buffer size
void	close() Closes this channel.
ByteBuffer	fetch(long position)
SeekableByteChannelPrefetcher.Statistics	getStatistics()
boolean	isOpen() Tells whether or not this channel is open.
long	position() Returns this channel's position.
SeekableByteChannel	position(long newPosition) Sets this channel's position.
int	read(ByteBuffer dst) Reads a sequence of bytes from this channel into the given buffer.
long	size() Returns the current size of entity to which this channel is connected.
SeekableByteChannel	truncate(long size) Not supported.
int	write(ByteBuffer src) Writing isn't supported.

Methods inherited from class java.lang.Object

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

Method Detail

addPrefetcher

public static SeekableByteChannel addPrefetcher(int bufferSizeMB,
                                                SeekableByteChannel channel)
                                         throws IOException

Wraps the provided SeekableByteChannel within a SeekableByteChannelPrefetcher, using the provided buffer size

Parameters:

bufferSizeMB - buffer size in MB

channel - channel to wrap in the prefetcher

Returns:

wrapped channel

Throws:

IOException

getStatistics

public SeekableByteChannelPrefetcher.Statistics getStatistics()

fetch

public ByteBuffer fetch(long position)
                 throws InterruptedException,
                        ExecutionException

Throws:

InterruptedException

ExecutionException

read

public int read(ByteBuffer dst)
         throws IOException

Reads a sequence of bytes from this channel into the given buffer.

Bytes are read starting at this channel's current position, and then the position is updated with the number of bytes actually read. Otherwise this method behaves exactly as specified in the ReadableByteChannel interface.

Specified by:

read in interface ReadableByteChannel

Specified by:

read in interface SeekableByteChannel

Parameters:

dst - buffer to write into

Throws:

IOException

write

public int write(ByteBuffer src)
          throws IOException

Writing isn't supported.

Specified by:

write in interface SeekableByteChannel

Specified by:

write in interface WritableByteChannel

Throws:

IOException

position

public long position()
              throws IOException

Returns this channel's position.

Specified by:

position in interface SeekableByteChannel

Returns:

This channel's position, a non-negative integer counting the number of bytes from the beginning of the entity to the current position

Throws:

ClosedChannelException - If this channel is closed

IOException - If some other I/O error occurs

position

public SeekableByteChannel position(long newPosition)
                             throws IOException

Sets this channel's position.

Setting the position to a value that is greater than the current size is legal but does not change the size of the entity. A later attempt to read bytes at such a position will immediately return an end-of-file indication. A later attempt to write bytes at such a position will cause the entity to grow to accommodate the new bytes; the values of any bytes between the previous end-of-file and the newly-written bytes are unspecified.

Setting the channel's position is not recommended when connected to an entity, typically a file, that is opened with the APPEND option. When opened for append, the position is first advanced to the end before writing.

Specified by:

position in interface SeekableByteChannel

Parameters:

newPosition - The new position, a non-negative integer counting the number of bytes from the beginning of the entity

Returns:

This channel

Throws:

ClosedChannelException - If this channel is closed

IllegalArgumentException - If the new position is negative

IOException - If some other I/O error occurs

size

public long size()
          throws IOException

Returns the current size of entity to which this channel is connected.

Specified by:

size in interface SeekableByteChannel

Returns:

The current size, measured in bytes

Throws:

ClosedChannelException - If this channel is closed

IOException - If some other I/O error occurs

truncate

public SeekableByteChannel truncate(long size)
                             throws IOException

Not supported.

Specified by:

truncate in interface SeekableByteChannel

Throws:

IOException

isOpen

public boolean isOpen()

Tells whether or not this channel is open.

Specified by:

isOpen in interface Channel

Returns:

true if, and only if, this channel is open

close

public void close()
           throws IOException

Closes this channel.

After a channel is closed, any further attempt to invoke I/O operations upon it will cause a ClosedChannelException to be thrown.

If this channel is already closed then invoking this method has no effect.

This method may be invoked at any time. If some other thread has already invoked it, however, then another invocation will block until the first invocation is complete, after which it will return without effect.

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

Specified by:

close in interface Channel

Throws:

IOException - If an I/O error occurs