## com.sun.grizzly.async
Interface AsyncQueueWriter

All Known Implementing Classes:
  AbstractAsyncQueueWriter, TCPAsyncQueueWriter, UDPAsyncQueueWriter

    public interface AsyncQueueWriter

Common inteface to be implemented by protocol dependant asynchronous queue writers implementations

Author:
  Alexey Stashok

Method Summary
`void` `close()` Close `AsyncQueueWriter` and release its resources
`boolean` `hasReadyAsyncWriteData(SelectionKey key)` Checks whether there is any data in `AsyncQueue` ready to be written to the `SelectableChannel`, associated with the given `SelectionKey`
`void` `onClose(SelectableChannel channel)` Callback method, which should be called by `SelectorHandler` to notify, that given `SelectableChannel` is going to be closed, so related `SelectableChannel` data could be released from `AsyncQueue`
`void` `onWrite(SelectionKey key)` Callback method, which should be called by `SelectorHandler` to notify, that `SelectableChannel`, associated with the given `SelectionKey` is ready to transmit data.
`void` `write(SelectionKey key, ByteBuffer buffer)` Method writes `ByteBuffer` to the `SelectableChannel` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SelectableChannel` directly (without putting to the queue).
`void` `write(SelectionKey key, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler)` Method writes `ByteBuffer` to the `SelectableChannel` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SelectableChannel` directly (without putting to the queue).
`void` `write(SelectionKey key, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor)` Method writes `ByteBuffer` to the `SelectableChannel` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SelectableChannel` directly (without putting to the queue).
`void` `write(SelectionKey key, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor, boolean isCloneByteBuffer)` Method writes `ByteBuffer` to the `SelectableChannel` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SelectableChannel` directly (without putting to the queue).
`void` `write(SelectionKey key, SocketAddress dstAddress, ByteBuffer buffer)` Method sends `ByteBuffer` to the `SocketAddress` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue).
`void` `write(SelectionKey key, SocketAddress dstAddress, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler)` Method sends `ByteBuffer` to the `SocketAddress` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue).
`void` `write(SelectionKey key, SocketAddress dstAddress, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor)` Method sends `ByteBuffer` to the `SocketAddress` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue).

`void`

`write(SelectionKey key, SocketAddress dstAddress, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor, boolean isCloneByteBuffer)`
Method sends `ByteBuffer` to the `SocketAddress` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue).

Method Detail

### write

    void write(SelectionKey key,
               ByteBuffer buffer)
               throws IOException

  Method writes `ByteBuffer` to the `SelectableChannel` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SelectableChannel` directly (without putting to the queue). If associated write queue is not empty or after direct writing `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue` and `SelectableChannel` will be registered on `SelectorHandler`, waiting for OP_WRITE event. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise it will be just logged by Grizzly framework.

  Parameters:
    `key` - `SelectionKey` associated with `SelectableChannel` `ByteBuffer` should be written to
    `buffer` - `ByteBuffer`
  Throws:
    `IOException`

### write

    void write(SelectionKey key,
               ByteBuffer buffer,
               AsyncWriteCallbackHandler callbackHandler)
               throws IOException

  Method writes `ByteBuffer` to the `SelectableChannel` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SelectableChannel` directly (without putting to the queue). If associated write queue is not empty or after direct writing `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue` and `SelectableChannel` will be registered on `SelectorHandler`, waiting for OP_WRITE event. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the `ByteBuffer` is added to a writing queue - exception notification will come via `AsyncWriteCallbackHandler.onIOException()`

  Parameters:
    `key` - `SelectionKey` associated with `SelectableChannel` `ByteBuffer` should be written to
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncWriteCallbackHandler`, which will get notified, when `ByteBuffer` will be completely written
  Throws:
    `IOException`

### write

    void write(SelectionKey key,
               ByteBuffer buffer,
               AsyncWriteCallbackHandler callbackHandler,
               AsyncQueueDataProcessor writePreProcessor)
               throws IOException

  Method writes `ByteBuffer` to the `SelectableChannel` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SelectableChannel` directly (without putting to the queue). If associated write queue is not empty or after direct writing `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue` and `SelectableChannel` will be registered on `SelectorHandler`, waiting for OP_WRITE event. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the `ByteBuffer` is added to a writing queue - exception notification will come via `AsyncWriteCallbackHandler.onIOException()` Before data will be written on `SelectableChannel`, first it will be passed for preprocessing to `AsyncQueueDataProcessor`, and then preprocessor result data (`AsyncQueueDataProcessor.getResultByteBuffer()`) will be written on the `SelectableChannel`.

  Parameters:
    `key` - `SelectionKey` associated with `SelectableChannel` `ByteBuffer` should be written to
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncWriteCallbackHandler`, which will get notified, when `ByteBuffer` will be completely written
    `writePreProcessor` - `AsyncQueueDataProcessor`, which will perform data processing, before it will be written on `SelectableChannel`
  Throws:
    `IOException`

### write

    void write(SelectionKey key,
               ByteBuffer buffer,
               AsyncWriteCallbackHandler callbackHandler,
               AsyncQueueDataProcessor writePreProcessor,
               boolean isCloneByteBuffer)
               throws IOException

  Method writes `ByteBuffer` to the `SelectableChannel` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SelectableChannel` directly (without putting to the queue). If associated write queue is not empty or after direct writing `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue` and `SelectableChannel` will be registered on `SelectorHandler`, waiting for OP_WRITE event. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the `ByteBuffer` is added to a writing queue - exception notification will come via `AsyncWriteCallbackHandler.onIOException()` Before data will be written on `SelectableChannel`, first it will be passed for preprocessing to `AsyncQueueDataProcessor`, and then preprocessor result data (`AsyncQueueDataProcessor.getResultByteBuffer()`) will be written on the `SelectableChannel`.

  Parameters:
    `key` - `SelectionKey` associated with `SelectableChannel` `ByteBuffer` should be written to
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncWriteCallbackHandler`, which will get notified, when `ByteBuffer` will be completely written
    `writePreProcessor` - `AsyncQueueDataProcessor`, which will perform data processing, before it will be written on `SelectableChannel`
    `isCloneByteBuffer` - if true - `AsyncQueueWriter` will clone given `ByteBuffer` before puting it to the `AsyncQueue`
  Throws:
    `IOException`

### write

    void write(SelectionKey key,
               SocketAddress dstAddress,
               ByteBuffer buffer)
               throws IOException

  Method sends `ByteBuffer` to the `SocketAddress` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue). If associated write queue is not empty or after direct writing `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue` and `SelectableChannel` will be registered on `SelectorHandler`, waiting for OP_WRITE event. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise it will be just logged by Grizzly framework.

  Parameters:
    `key` - `SelectionKey` associated with `SelectableChannel`, which will be used to send`ByteBuffer` to
    `dstAddress` - destination address `ByteBuffer` will be sent to
    `buffer` - `ByteBuffer`
  Throws:
    `IOException`

### write

    void write(SelectionKey key,
               SocketAddress dstAddress,
               ByteBuffer buffer,
               AsyncWriteCallbackHandler callbackHandler)
               throws IOException

  Method sends `ByteBuffer` to the `SocketAddress` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue). If associated write queue is not empty or after direct writing `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue` and `SelectableChannel` will be registered on `SelectorHandler`, waiting for OP_WRITE event. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the `ByteBuffer` is added to a writing queue - exception notification will come via `AsyncWriteCallbackHandler.onIOException()`

  Parameters:
    `key` - `SelectionKey` associated with `SelectableChannel` `ByteBuffer` should be written to
    `dstAddress` - destination address `ByteBuffer` will be sent to
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncWriteCallbackHandler`, which will get notified, when `ByteBuffer` will be completely written
  Throws:
    `IOException`

### write

    void write(SelectionKey key,
               SocketAddress dstAddress,
               ByteBuffer buffer,
               AsyncWriteCallbackHandler callbackHandler,
               AsyncQueueDataProcessor writePreProcessor)
               throws IOException

  Method sends `ByteBuffer` to the `SocketAddress` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue). If associated write queue is not empty or after direct writing `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue` and `SelectableChannel` will be registered on `SelectorHandler`, waiting for OP_WRITE event. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the `ByteBuffer` is added to a writing queue - exception notification will come via `AsyncWriteCallbackHandler.onIOException()` Before data will be written on `SelectableChannel`, first it will be passed for preprocessing to `AsyncQueueDataProcessor`, and then preprocessor result data (`AsyncQueueDataProcessor.getResultByteBuffer()`) will be written on the `SelectableChannel`.

  Parameters:
    `key` - `SelectionKey` associated with `SelectableChannel` `ByteBuffer` should be written to
    `dstAddress` - destination address `ByteBuffer` will be sent to
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncWriteCallbackHandler`, which will get notified, when `ByteBuffer` will be completely written
    `writePreProcessor` - `AsyncQueueDataProcessor`, which will perform data processing, before it will be written on `SelectableChannel`
  Throws:
    `IOException`

### write

    void write(SelectionKey key,
               SocketAddress dstAddress,
               ByteBuffer buffer,
               AsyncWriteCallbackHandler callbackHandler,
               AsyncQueueDataProcessor writePreProcessor,
               boolean isCloneByteBuffer)
               throws IOException

  Method sends `ByteBuffer` to the `SocketAddress` First, if `SelectableChannel` associated write queue is empty - it tries to write `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue). If associated write queue is not empty or after direct writing `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue` and `SelectableChannel` will be registered on `SelectorHandler`, waiting for OP_WRITE event. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the `ByteBuffer` is added to a writing queue - exception notification will come via `AsyncWriteCallbackHandler.onIOException()` Before data will be written on `SelectableChannel`, first it will be passed for preprocessing to `AsyncQueueDataProcessor`, and then preprocessor result data (`AsyncQueueDataProcessor.getResultByteBuffer()`) will be written on the `SelectableChannel`.

  Parameters:
    `key` - `SelectionKey` associated with `SelectableChannel` `ByteBuffer` should be written to
    `dstAddress` - destination address `ByteBuffer` will be sent to
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncWriteCallbackHandler`, which will get notified, when `ByteBuffer` will be completely written
    `writePreProcessor` - `AsyncQueueDataProcessor`, which will perform data processing, before it will be written on `SelectableChannel`
    `isCloneByteBuffer` - if true - `AsyncQueueWriter` will clone given `ByteBuffer` before puting it to the `AsyncQueue`
  Throws:
    `IOException`

### hasReadyAsyncWriteData

    boolean hasReadyAsyncWriteData(SelectionKey key)

  Checks whether there is any data in `AsyncQueue` ready to be written to the `SelectableChannel`, associated with the given `SelectionKey`

  Parameters:
    `key` - `SelectionKey` associated with `SelectableChannel`
  Returns:
    true, if there is ready data. False otherwise.

### onWrite

    void onWrite(SelectionKey key)
                 throws IOException

  Callback method, which should be called by `SelectorHandler` to notify, that `SelectableChannel`, associated with the given `SelectionKey` is ready to transmit data.

  Parameters:
    `key` - `SelectionKey` associated with `SelectableChannel`
  Throws:
    `IOException`

### onClose

    void onClose(SelectableChannel channel)

  Callback method, which should be called by `SelectorHandler` to notify, that given `SelectableChannel` is going to be closed, so related `SelectableChannel` data could be released from `AsyncQueue`

  Parameters:
    `{@link` - SelectableChannel}
  Throws:
    `IOException`

### close

    void close()

  Close `AsyncQueueWriter` and release its resources

Copyright © 2008 SUN Microsystems. All Rights Reserved.