| Inherited functions |
From class AbstractInterruptibleChannel
Unit |
begin()
Marks the beginning of an I/O operation that might block indefinitely.
This method should be invoked in tandem with the end method, using a try ... finally block as shown above, in order to implement asynchronous closing and interruption for this channel.
|
Unit |
close()
Closes this channel.
If the channel has already been closed then this method returns immediately. Otherwise it marks the channel as closed and then invokes the implCloseChannel method in order to complete the close operation.
|
Unit |
end(completed: Boolean)
Marks the end of an I/O operation that might block indefinitely.
This method should be invoked in tandem with the begin method, using a try ... finally block as shown above, in order to implement asynchronous closing and interruption for this channel.
|
Unit |
implCloseChannel()
Closes this channel.
This method is invoked by the #close method in order to perform the actual work of closing the channel. This method is only invoked if the channel has not yet been closed, and it is never invoked more than once.
An implementation of this method must arrange for any other thread that is blocked in an I/O operation upon this channel to return immediately, either by throwing an exception or by returning normally.
|
Boolean |
isOpen()
|
|
From class AbstractSelectableChannel
Any! |
blockingLock()
|
SelectableChannel! |
configureBlocking(block: Boolean)
Adjusts this channel's blocking mode.
If the given blocking mode is different from the current blocking mode then this method invokes the implConfigureBlocking method, while holding the appropriate locks, in order to change the mode.
|
Unit |
implCloseChannel()
Closes this channel.
This method, which is specified in the AbstractInterruptibleChannel class and is invoked by the java.nio.channels.Channel#close method, in turn invokes the implCloseSelectableChannel method in order to perform the actual work of closing this channel. It then cancels all of this channel's keys.
|
Unit |
implCloseSelectableChannel()
Closes this selectable channel.
This method is invoked by the java.nio.channels.Channel#close method in order to perform the actual work of closing the channel. This method is only invoked if the channel has not yet been closed, and it is never invoked more than once.
An implementation of this method must arrange for any other thread that is blocked in an I/O operation upon this channel to return immediately, either by throwing an exception or by returning normally.
|
Unit |
implConfigureBlocking(block: Boolean)
Adjusts this channel's blocking mode.
This method is invoked by the configureBlocking method in order to perform the actual work of changing the blocking mode. This method is only invoked if the new mode is different from the current mode.
|
Boolean |
isBlocking()
|
Boolean |
isRegistered()
|
SelectionKey! |
keyFor(sel: Selector!)
|
SelectorProvider! |
provider()
Returns the provider that created this channel.
|
SelectionKey! |
register(sel: Selector!, ops: Int, att: Any!)
Registers this channel with the given selector, returning a selection key.
This method first verifies that this channel is open and that the given initial interest set is valid.
If this channel is already registered with the given selector then the selection key representing that registration is returned after setting its interest set to the given value.
Otherwise this channel has not yet been registered with the given selector, so the register method of the selector is invoked while holding the appropriate locks. The resulting key is added to this channel's key set before being returned.
|
|
From class Channel
Unit |
close()
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.
|
Unit |
close()
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.
|
Boolean |
isOpen()
Tells whether or not this channel is open.
|
Boolean |
isOpen()
Tells whether or not this channel is open.
|
|
From class ReadableByteChannel
Int |
read(dst: ByteBuffer!)
Reads a sequence of bytes from this channel into the given buffer.
An attempt is made to read up to r bytes from the channel, where r is the number of bytes remaining in the buffer, that is, dst.remaining(), at the moment this method is invoked.
Suppose that a byte sequence of length n is read, where 0 <= n <= r. This byte sequence will be transferred into the buffer so that the first byte in the sequence is at index p and the last byte is at index p + n - 1, where p is the buffer's position at the moment this method is invoked. Upon return the buffer's position will be equal to p + n; its limit will not have changed.
A read operation might not fill the buffer, and in fact it might not read any bytes at all. Whether or not it does so depends upon the nature and state of the channel. A socket channel in non-blocking mode, for example, cannot read any more bytes than are immediately available from the socket's input buffer; similarly, a file channel cannot read any more bytes than remain in the file. It is guaranteed, however, that if a channel is in blocking mode and there is at least one byte remaining in the buffer then this method will block until at least one byte is read.
This method may be invoked at any time. If another thread has already initiated a read operation upon this channel, however, then an invocation of this method will block until the first operation is complete.
|
Int |
read(dst: ByteBuffer!)
Reads a sequence of bytes from this channel into the given buffer.
An attempt is made to read up to r bytes from the channel, where r is the number of bytes remaining in the buffer, that is, dst.remaining(), at the moment this method is invoked.
Suppose that a byte sequence of length n is read, where 0 <= n <= r. This byte sequence will be transferred into the buffer so that the first byte in the sequence is at index p and the last byte is at index p + n - 1, where p is the buffer's position at the moment this method is invoked. Upon return the buffer's position will be equal to p + n; its limit will not have changed.
A read operation might not fill the buffer, and in fact it might not read any bytes at all. Whether or not it does so depends upon the nature and state of the channel. A socket channel in non-blocking mode, for example, cannot read any more bytes than are immediately available from the socket's input buffer; similarly, a file channel cannot read any more bytes than remain in the file. It is guaranteed, however, that if a channel is in blocking mode and there is at least one byte remaining in the buffer then this method will block until at least one byte is read.
This method may be invoked at any time. If another thread has already initiated a read operation upon this channel, however, then an invocation of this method will block until the first operation is complete.
|
|
From class ScatteringByteChannel
Long |
read(dsts: Array<ByteBuffer!>!, offset: Int, length: Int)
Reads a sequence of bytes from this channel into a subsequence of the given buffers.
An invocation of this method attempts to read up to r bytes from this channel, where r is the total number of bytes remaining the specified subsequence of the given buffer array, that is,
dsts[offset].remaining()
+ dsts[offset+1].remaining()
+ ... + dsts[offset+length-1].remaining()
at the moment that this method is invoked.
Suppose that a byte sequence of length n is read, where 0 <= n <= r. Up to the first dsts[offset].remaining() bytes of this sequence are transferred into buffer dsts[offset], up to the next dsts[offset+1].remaining() bytes are transferred into buffer dsts[offset+1], and so forth, until the entire byte sequence is transferred into the given buffers. As many bytes as possible are transferred into each buffer, hence the final position of each updated buffer, except the last updated buffer, is guaranteed to be equal to that buffer's limit.
This method may be invoked at any time. If another thread has already initiated a read operation upon this channel, however, then an invocation of this method will block until the first operation is complete.
|
Long |
read(dsts: Array<ByteBuffer!>!)
Reads a sequence of bytes from this channel into the given buffers.
An invocation of this method of the form c.read(dsts) behaves in exactly the same manner as the invocation
c.read(dsts, 0, dsts.length);
|
|
From class SelectableChannel
SelectionKey! |
register(sel: Selector!, ops: Int)
Registers this channel with the given selector, returning a selection key.
An invocation of this convenience method of the form
sc.register(sel, ops) behaves in exactly the same way as the invocation sc. register(sel, ops, null)
|
Int |
validOps()
Returns an operation set identifying this channel's supported operations. The bits that are set in this integer value denote exactly the operations that are valid for this channel. This method always returns the same value for a given concrete channel class.
|
|
