## com.sun.grizzly
Class UDPConnectorHandler

    java.lang.Object
      com.sun.grizzly.UDPConnectorHandler

All Implemented Interfaces:
  AsyncQueueReadable, AsyncQueueWritable, ConnectorHandler<UDPSelectorHandler,CallbackHandler>, Handler, Closeable

    public class UDPConnectorHandler

extends Object
implements ConnectorHandler<UDPSelectorHandler,CallbackHandler>, AsyncQueueWritable, AsyncQueueReadable

Client side interface used to implement non blocking client operation. Implementation of this class must make sure the following methods are invoked in that order:

     (1) connect()
     (2) read() or write().

Author:
  Jeanfrancois Arcand

Field Summary
`protected CallbackHandler` `callbackHandler` A `CallbackHandler` handler invoked by the UDPSelectorHandler when a non blocking operation is ready to be processed.
`protected Controller` `controller` The internal Controller used (in case not specified).
`protected DatagramChannel` `datagramChannel` The connection's DatagramChannel.
`protected InputReader` `inputStream` A blocking `InputStream` that use a pool of Selector to execute a blocking read operation.
`protected boolean` `isConnected` Is the connection established.
`protected CountDownLatch` `isConnectedLatch` IsConnected Latch related
`protected UDPSelectorHandler` `selectorHandler` The underlying UDPSelectorHandler used to mange SelectionKeys.

Constructor Summary
`UDPConnectorHandler()`

Method Summary
`void` `close()` Close the underlying connection.
`void` `connect(SocketAddress remoteAddress)` Connect to hostname:port.
`void` `connect(SocketAddress remoteAddress, CallbackHandler callbackHandler)` Connect to hostname:port.
`void` `connect(SocketAddress remoteAddress, CallbackHandler callbackHandler, UDPSelectorHandler selectorHandler)` Connect to hostname:port.
`void` `connect(SocketAddress remoteAddress, SocketAddress localAddress)` Connect to hostname:port.
`void` `connect(SocketAddress remoteAddress, SocketAddress localAddress, CallbackHandler callbackHandler)` Connect to hostname:port.
`void` `connect(SocketAddress remoteAddress, SocketAddress localAddress, CallbackHandler callbackHandler, UDPSelectorHandler selectorHandler)` Connect to hostname:port.
`void` `finishConnect(SelectionKey key)` Finish handling the OP_CONNECT interest ops.
`CallbackHandler` `getCallbackHandler()` Return the `CallbackHandler`.
`Controller` `getController()` Return the `Controller`
`UDPSelectorHandler` `getSelectorHandler()` Return the associated `SelectorHandler`.
`SelectableChannel` `getUnderlyingChannel()` Return the current `SocketChannel` used.
`boolean` `isConnected()` Is the underlying DatagramChannel connected.
`Controller.Protocol` `protocol()` A token decribing the protocol supported by an implementation of this interface
`long` `read(ByteBuffer byteBuffer, boolean blocking)` Read bytes.
`void` `readFromAsyncQueue(ByteBuffer buffer, AsyncReadCallbackHandler callbackHandler)` Method reads data to the `ByteBuffer` using async read queue.
`void` `readFromAsyncQueue(ByteBuffer buffer, AsyncReadCallbackHandler callbackHandler, AsyncReadCondition condition)` Method reads data to the `ByteBuffer` using async read queue.
`void` `readFromAsyncQueue(ByteBuffer buffer, AsyncReadCallbackHandler callbackHandler, AsyncReadCondition condition, AsyncQueueDataProcessor readPostProcessor)` Method reads data to the `ByteBuffer` using async read queue.
`SocketAddress` `receive(ByteBuffer byteBuffer)` Receive bytes.
`long` `send(ByteBuffer byteBuffer, SocketAddress socketAddress)` Receive bytes.
`void` `setCallbackHandler(CallbackHandler callbackHandler)` Set the `CallbackHandler`.
`void` `setController(Controller controller)` Set the `Controller` to use with this instance.
`long` `write(ByteBuffer byteBuffer, boolean blocking)` Writes bytes.
`void` `writeToAsyncQueue(ByteBuffer buffer)` Method writes `ByteBuffer` using async write queue.
`void` `writeToAsyncQueue(ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler)` Method writes `ByteBuffer` using async write queue.
`void` `writeToAsyncQueue(ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor)` Method writes `ByteBuffer` using async write queue.
`void` `writeToAsyncQueue(ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor, boolean isCloneByteBuffer)` Method writes `ByteBuffer` using async write queue.
`void` `writeToAsyncQueue(SocketAddress dstAddress, ByteBuffer buffer)` Method sends `ByteBuffer` using async write queue.
`void` `writeToAsyncQueue(SocketAddress dstAddress, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler)` Method sends `ByteBuffer` using async write queue.
`void` `writeToAsyncQueue(SocketAddress dstAddress, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor)` Method sends `ByteBuffer` using async write queue.
`void` `writeToAsyncQueue(SocketAddress dstAddress, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor, boolean isCloneByteBuffer)` Method sends `ByteBuffer` using async write queue.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### selectorHandler

    protected UDPSelectorHandler selectorHandler

  The underlying UDPSelectorHandler used to mange SelectionKeys.

### callbackHandler

    protected CallbackHandler callbackHandler

  A `CallbackHandler` handler invoked by the UDPSelectorHandler when a non blocking operation is ready to be processed.

### datagramChannel

    protected DatagramChannel datagramChannel

  The connection's DatagramChannel.

### isConnected

    protected volatile boolean isConnected

  Is the connection established.

### controller

    protected Controller controller

  The internal Controller used (in case not specified).

### isConnectedLatch

    protected CountDownLatch isConnectedLatch

  IsConnected Latch related

### inputStream

    protected InputReader inputStream

  A blocking `InputStream` that use a pool of Selector to execute a blocking read operation.

Constructor Detail

### UDPConnectorHandler

    public UDPConnectorHandler()

Method Detail

### connect

    public void connect(SocketAddress remoteAddress,
                        CallbackHandler callbackHandler)
                 throws IOException

  Connect to hostname:port. When an aysnchronous event happens (e.g OP_READ or OP_WRITE), the `Controller` will invoke the CallBackHandler.

  Specified by:
    `connect` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `remoteAddress` - remote address to connect
    `callbackHandler` - the handler invoked by its associated `SelectorHandler` when a non blocking operation is ready to be handled. When null, all read and write operation will be delegated to the default `ProtocolChain` and its list of `ProtocolFilter` . When null, this `ConnectorHandler` will create an instance of `DefaultCallbackHandler`.
  Throws:
    `IOException`

### connect

    public void connect(SocketAddress remoteAddress,
                        SocketAddress localAddress,
                        CallbackHandler callbackHandler)
                 throws IOException

  Connect to hostname:port. When an aysnchronous event happens (e.g OP_READ or OP_WRITE), the `Controller` will invoke the CallBackHandler.

  Specified by:
    `connect` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `remoteAddress` - remote address to connect
    `localAddress` - local address to bind
    `callbackHandler` - the handler invoked by its associated `SelectorHandler` when a non blocking operation is ready to be handled. When null, all read and write operation will be delegated to the default `ProtocolChain` and its list of `ProtocolFilter` . When null, this `ConnectorHandler` will create an instance of `DefaultCallbackHandler`.
  Throws:
    `IOException`

### connect

    public void connect(SocketAddress remoteAddress,
                        CallbackHandler callbackHandler,
                        UDPSelectorHandler selectorHandler)
                 throws IOException

  Connect to hostname:port. When an aysnchronous event happens (e.g OP_READ or OP_WRITE), the `Controller` will invoke the CallBackHandler.

  Specified by:
    `connect` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `remoteAddress` - remote address to connect
    `callbackHandler` - the handler invoked by its associated `SelectorHandler` when a non blocking operation is ready to be handled. When null, all read and write operation will be delegated to the default `ProtocolChain` and its list of `ProtocolFilter` . When null, this `ConnectorHandler` will create an instance of `DefaultCallbackHandler`.
    `selectorHandler` - an instance of SelectorHandler.
  Throws:
    `IOException`

### connect

    public void connect(SocketAddress remoteAddress,
                        SocketAddress localAddress,
                        CallbackHandler callbackHandler,
                        UDPSelectorHandler selectorHandler)
                 throws IOException

  Connect to hostname:port. When an aysnchronous event happens (e.g OP_READ or OP_WRITE), the `Controller` will invoke the CallBackHandler.

  Specified by:
    `connect` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `remoteAddress` - remote address to connect
    `localAddress` - local address to bin
    `callbackHandler` - the handler invoked by its associated `SelectorHandler` when a non blocking operation is ready to be handled. When null, all read and write operation will be delegated to the default `ProtocolChain` and its list of `ProtocolFilter` . When null, this `ConnectorHandler` will create an instance of `DefaultCallbackHandler`.
    `selectorHandler` - an instance of SelectorHandler.
  Throws:
    `IOException`

### connect

    public void connect(SocketAddress remoteAddress)
                 throws IOException

  Connect to hostname:port. Internally an instance of Controller and its default SelectorHandler will be created everytime this method is called. This method should be used only and only if no external Controller has been initialized.

  Specified by:
    `connect` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `remoteAddress` - remote address to connect
  Throws:
    `IOException`

### connect

    public void connect(SocketAddress remoteAddress,
                        SocketAddress localAddress)
                 throws IOException

  Connect to hostname:port. Internally an instance of Controller and its default SelectorHandler will be created everytime this method is called. This method should be used only and only if no external Controller has been initialized.

  Specified by:
    `connect` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `remoteAddress` - remote address to connect
    `localAddress` - local address to bin
  Throws:
    `IOException`

### read

    public long read(ByteBuffer byteBuffer,
                     boolean blocking)
              throws IOException

  Read bytes. If blocking is set to `true`, a pool of temporary `Selector` will be used to read bytes.

  Specified by:
    `read` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `byteBuffer` - The byteBuffer to store bytes.
    `blocking` - `true` if a a pool of temporary Selector is required to handle a blocking read.
  Returns:
    number of bytes read
  Throws:
    `IOException`

### write

    public long write(ByteBuffer byteBuffer,
                      boolean blocking)
               throws IOException

  Writes bytes. If blocking is set to `true`, a pool of temporary `Selector` will be used to writes bytes.

  Specified by:
    `write` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `byteBuffer` - The byteBuffer to write.
    `blocking` - `true` if a a pool of temporary Selector is required to handle a blocking write.
  Returns:
    number of bytes written
  Throws:
    `IOException`

### readFromAsyncQueue

    public void readFromAsyncQueue(ByteBuffer buffer,
                                   AsyncReadCallbackHandler callbackHandler)
                            throws IOException

  Method reads data to the `ByteBuffer` using async read queue. First, if read queue is empty - it tries to read to the `ByteBuffer` directly (without putting to the queue). If associated read queue is not empty or after direct reading `ByteBuffer` still has remaining place for next read - `ByteBuffer` will be added to `AsyncQueue`. If an exception occurs, during direct reading - it will be propagated to the caller directly, otherwise, if the `ByteBuffer` is added to a reading queue - exception notification will come via `AsyncReadCallbackHandler.onIOException()`

  Specified by:
    `readFromAsyncQueue` in interface `AsyncQueueReadable`
  Parameters:
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncReadCallbackHandler`, which will get notified, when `ByteBuffer` will get full
  Throws:
    `IOException`

### readFromAsyncQueue

    public void readFromAsyncQueue(ByteBuffer buffer,
                                   AsyncReadCallbackHandler callbackHandler,
                                   AsyncReadCondition condition)
                            throws IOException

  Method reads data to the `ByteBuffer` using async read queue. First, if read queue is empty - it tries to read to the `ByteBuffer` directly (without putting to the queue). If associated read queue is not empty or after direct reading `ByteBuffer` still has remaining place for next read - `ByteBuffer` will be added to `AsyncQueue`. If an exception occurs, during direct reading - it will be propagated to the caller directly, otherwise, if the `ByteBuffer` is added to a reading queue - exception notification will come via `AsyncReadCallbackHandler.onIOException()`

  Specified by:
    `readFromAsyncQueue` in interface `AsyncQueueReadable`
  Parameters:
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncReadCallbackHandler`, which will get notified, when `ByteBuffer` will get full
    `condition` - `AsyncReadCondition`, which will be called to check if read data is complete, and callbackHandler could be called
  Throws:
    `IOException`

### readFromAsyncQueue

    public void readFromAsyncQueue(ByteBuffer buffer,
                                   AsyncReadCallbackHandler callbackHandler,
                                   AsyncReadCondition condition,
                                   AsyncQueueDataProcessor readPostProcessor)
                            throws IOException

  Method reads data to the `ByteBuffer` using async read queue. First, if read queue is empty - it tries to read to the `ByteBuffer` directly (without putting to the queue). If associated read queue is not empty or after direct reading `ByteBuffer` still has remaining place for next read - `ByteBuffer` will be added to `AsyncQueue`. If an exception occurs, during direct reading - it will be propagated to the caller directly, otherwise, if the `ByteBuffer` is added to a reading queue - exception notification will come via `AsyncReadCallbackHandler.onIOException()`

  Specified by:
    `readFromAsyncQueue` in interface `AsyncQueueReadable`
  Parameters:
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncReadCallbackHandler`, which will get notified, when `ByteBuffer` will get full
    `condition` - `AsyncReadCondition`, which will be called to check if read data is complete, and callbackHandler could be called
    `readPostProcessor` - post processor, to be called to process read data
  Throws:
    `IOException`

### writeToAsyncQueue

    public void writeToAsyncQueue(ByteBuffer buffer)
                           throws IOException

  Method writes `ByteBuffer` using async write queue. First, if write queue is empty - it tries to write `ByteBuffer` 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`. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise it will be just logged by Grizzly framework.

  Specified by:
    `writeToAsyncQueue` in interface `AsyncQueueWritable`
  Parameters:
    `buffer` - `ByteBuffer`
  Throws:
    `IOException`

### writeToAsyncQueue

    public void writeToAsyncQueue(ByteBuffer buffer,
                                  AsyncWriteCallbackHandler callbackHandler)
                           throws IOException

  Method writes `ByteBuffer` using async write queue. First, if write queue is empty - it tries to write `ByteBuffer` 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`. 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()`

  Specified by:
    `writeToAsyncQueue` in interface `AsyncQueueWritable`
  Parameters:
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncWriteCallbackHandler`, which will get notified, when `ByteBuffer` will be completely written
  Throws:
    `IOException`

### writeToAsyncQueue

    public void writeToAsyncQueue(ByteBuffer buffer,
                                  AsyncWriteCallbackHandler callbackHandler,
                                  AsyncQueueDataProcessor writePreProcessor)
                           throws IOException

  Method writes `ByteBuffer` using async write queue. First, if write queue is empty - it tries to write `ByteBuffer` 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`. 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`.

  Specified by:
    `writeToAsyncQueue` in interface `AsyncQueueWritable`
  Parameters:
    `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`

### writeToAsyncQueue

    public void writeToAsyncQueue(ByteBuffer buffer,
                                  AsyncWriteCallbackHandler callbackHandler,
                                  AsyncQueueDataProcessor writePreProcessor,
                                  boolean isCloneByteBuffer)
                           throws IOException

  Method writes `ByteBuffer` using async write queue. First, if write queue is empty - it tries to write `ByteBuffer` 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`. 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`.

  Specified by:
    `writeToAsyncQueue` in interface `AsyncQueueWritable`
  Parameters:
    `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`

### writeToAsyncQueue

    public void writeToAsyncQueue(SocketAddress dstAddress,
                                  ByteBuffer buffer)
                           throws IOException

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

  Specified by:
    `writeToAsyncQueue` in interface `AsyncQueueWritable`
  Parameters:
    `dstAddress` - destination `SocketAddress` data will be sent to
    `buffer` - `ByteBuffer`
  Throws:
    `IOException`

### writeToAsyncQueue

    public void writeToAsyncQueue(SocketAddress dstAddress,
                                  ByteBuffer buffer,
                                  AsyncWriteCallbackHandler callbackHandler)
                           throws IOException

  Method sends `ByteBuffer` using async write queue. First, if write queue is empty - it tries to send `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue). If associated write queue is not empty or after direct sending `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue`. 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()`

  Specified by:
    `writeToAsyncQueue` in interface `AsyncQueueWritable`
  Parameters:
    `dstAddress` - destination `SocketAddress` data will be sent to
    `buffer` - `ByteBuffer`
    `callbackHandler` - `AsyncWriteCallbackHandler`, which will get notified, when `ByteBuffer` will be completely written
  Throws:
    `IOException`

### writeToAsyncQueue

    public void writeToAsyncQueue(SocketAddress dstAddress,
                                  ByteBuffer buffer,
                                  AsyncWriteCallbackHandler callbackHandler,
                                  AsyncQueueDataProcessor writePreProcessor)
                           throws IOException

  Method sends `ByteBuffer` using async write queue. First, if write queue is empty - it tries to send `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue). If associated write queue is not empty or after direct sending `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue`. 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`.

  Specified by:
    `writeToAsyncQueue` in interface `AsyncQueueWritable`
  Parameters:
    `dstAddress` - destination `SocketAddress` data 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`

### writeToAsyncQueue

    public void writeToAsyncQueue(SocketAddress dstAddress,
                                  ByteBuffer buffer,
                                  AsyncWriteCallbackHandler callbackHandler,
                                  AsyncQueueDataProcessor writePreProcessor,
                                  boolean isCloneByteBuffer)
                           throws IOException

  Method sends `ByteBuffer` using async write queue. First, if write queue is empty - it tries to send `ByteBuffer` to the given `SocketAddress` directly (without putting to the queue). If associated write queue is not empty or after direct sending `ByteBuffer` still has ready data to be written - `ByteBuffer` will be added to `AsyncQueue`. 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`.

  Specified by:
    `writeToAsyncQueue` in interface `AsyncQueueWritable`
  Parameters:
    `dstAddress` - destination `SocketAddress` data 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`

### send

    public long send(ByteBuffer byteBuffer,
                     SocketAddress socketAddress)
              throws IOException

  Receive bytes.

  Parameters:
    `byteBuffer` - The byteBuffer to store bytes.
    `socketAddress` -
  Returns:
    number bytes sent
  Throws:
    `IOException`

### receive

    public SocketAddress receive(ByteBuffer byteBuffer)
                          throws IOException

  Receive bytes.

  Parameters:
    `byteBuffer` - The byteBuffer to store bytes.
  Returns:
    `SocketAddress`
  Throws:
    `IOException`

### close

    public void close()
               throws IOException

  Close the underlying connection.

  Specified by:
    `close` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Specified by:
    `close` in interface `Closeable`
  Throws:
    `IOException`

### finishConnect

    public void finishConnect(SelectionKey key)
                       throws IOException

  Finish handling the OP_CONNECT interest ops.

  Specified by:
    `finishConnect` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `key` - `SelectionKey`
  Throws:
    `IOException`

### protocol

    public Controller.Protocol protocol()

  A token decribing the protocol supported by an implementation of this interface

  Specified by:
    `protocol` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Returns:
    `Controller.Protocol`

### isConnected

    public boolean isConnected()

  Is the underlying DatagramChannel connected.

  Returns:
    true if connected, othewise false

### getController

    public Controller getController()

  Return the `Controller`

  Specified by:
    `getController` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Returns:
    the `Controller`

### setController

    public void setController(Controller controller)

  Set the `Controller` to use with this instance.

  Specified by:
    `setController` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `controller` - the `Controller` to use with this instance.

### getUnderlyingChannel

    public SelectableChannel getUnderlyingChannel()

  Return the current `SocketChannel` used.

  Specified by:
    `getUnderlyingChannel` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Returns:
    the current `SocketChannel` used.

### getCallbackHandler

    public CallbackHandler getCallbackHandler()

  Return the `CallbackHandler`.

  Specified by:
    `getCallbackHandler` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Returns:
    the `CallbackHandler`.

### setCallbackHandler

    public void setCallbackHandler(CallbackHandler callbackHandler)

  Set the `CallbackHandler`.

  Specified by:
    `setCallbackHandler` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Parameters:
    `callbackHandler` - the `CallbackHandler`.

### getSelectorHandler

    public UDPSelectorHandler getSelectorHandler()

  Return the associated `SelectorHandler`.

  Specified by:
    `getSelectorHandler` in interface `ConnectorHandler<UDPSelectorHandler,CallbackHandler>`
  Returns:
    the associated `SelectorHandler`.

Copyright © 2008 SUN Microsystems. All Rights Reserved.