| 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 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.
|
|
From class WritableByteChannel
Int |
write(src: ByteBuffer!)
Writes a sequence of bytes to this channel from the given buffer.
An attempt is made to write up to r bytes to the channel, where r is the number of bytes remaining in the buffer, that is, src.remaining(), at the moment this method is invoked.
Suppose that a byte sequence of length n is written, where 0 <= n <= r. This byte sequence will be transferred from the buffer starting at index p, where p is the buffer's position at the moment this method is invoked; the index of the last byte written will be p + n - 1. Upon return the buffer's position will be equal to p + n; its limit will not have changed.
Unless otherwise specified, a write operation will return only after writing all of the r requested bytes. Some types of channels, depending upon their state, may write only some of the bytes or possibly none at all. A socket channel in non-blocking mode, for example, cannot write any more bytes than are free in the socket's output buffer.
This method may be invoked at any time. If another thread has already initiated a write operation upon this channel, however, then an invocation of this method will block until the first operation is complete.
|
Int |
write(src: ByteBuffer!)
Writes a sequence of bytes to this channel from the given buffer.
An attempt is made to write up to r bytes to the channel, where r is the number of bytes remaining in the buffer, that is, src.remaining(), at the moment this method is invoked.
Suppose that a byte sequence of length n is written, where 0 <= n <= r. This byte sequence will be transferred from the buffer starting at index p, where p is the buffer's position at the moment this method is invoked; the index of the last byte written will be p + n - 1. Upon return the buffer's position will be equal to p + n; its limit will not have changed.
Unless otherwise specified, a write operation will return only after writing all of the r requested bytes. Some types of channels, depending upon their state, may write only some of the bytes or possibly none at all. A socket channel in non-blocking mode, for example, cannot write any more bytes than are free in the socket's output buffer.
This method may be invoked at any time. If another thread has already initiated a write operation upon this channel, however, then an invocation of this method will block until the first operation is complete.
|
|
From class GatheringByteChannel
Long |
write(srcs: Array<ByteBuffer!>!, offset: Int, length: Int)
Writes a sequence of bytes to this channel from a subsequence of the given buffers.
An attempt is made to write up to r bytes to this channel, where r is the total number of bytes remaining in the specified subsequence of the given buffer array, that is,
srcs[offset].remaining()
+ srcs[offset+1].remaining()
+ ... + srcs[offset+length-1].remaining()
at the moment that this method is invoked.
Suppose that a byte sequence of length n is written, where 0 <= n <= r. Up to the first srcs[offset].remaining() bytes of this sequence are written from buffer srcs[offset], up to the next srcs[offset+1].remaining() bytes are written from buffer srcs[offset+1], and so forth, until the entire byte sequence is written. As many bytes as possible are written from 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.
Unless otherwise specified, a write operation will return only after writing all of the r requested bytes. Some types of channels, depending upon their state, may write only some of the bytes or possibly none at all. A socket channel in non-blocking mode, for example, cannot write any more bytes than are free in the socket's output buffer.
This method may be invoked at any time. If another thread has already initiated a write operation upon this channel, however, then an invocation of this method will block until the first operation is complete.
|
Long |
write(srcs: Array<ByteBuffer!>!)
Writes a sequence of bytes to this channel from the given buffers.
An invocation of this method of the form c.write(srcs) behaves in exactly the same manner as the invocation
c.write(srcs, 0, srcs.length);
|
|
