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.

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