Added in API level 1

SinkChannel

abstract class SinkChannel : AbstractSelectableChannel, GatheringByteChannel, WritableByteChannel

kotlin.Any
↳	java.nio.channels.spi.AbstractInterruptibleChannel
	↳	java.nio.channels.SelectableChannel
		↳	java.nio.channels.spi.AbstractSelectableChannel
			↳	java.nio.channels.Pipe.SinkChannel

A channel representing the writable end of a Pipe.

Summary

Protected constructors
SinkChannel(provider: SelectorProvider!) Initializes a new instance of this class.

Public methods
Int	validOps() Returns an operation set identifying this channel's supported operations.

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. 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 GatheringByteChannel 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); 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.
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.

Protected constructors

SinkChannel

Added in API level 1

protected SinkChannel(provider: SelectorProvider!)

Initializes a new instance of this class.

Parameters
provider	SelectorProvider!: The selector provider

Public methods

validOps

Added in API level 1

fun validOps(): Int

Returns an operation set identifying this channel's supported operations.

Pipe-sink channels only support writing, so this method returns SelectionKey.OP_WRITE.

Return
Int	The valid-operation set