io.vertx.core.datagram

## Interface DatagramSocket

- All Superinterfaces:
    Measured, ReadStream<DatagramPacket>, StreamBase

      public interface DatagramSocket
      extends ReadStream<DatagramPacket>, Measured

  A datagram socket can be used to send `DatagramPacket`'s to remote datagram servers and receive `DatagramPacket`s .

  Usually you use a datagram socket to send UDP over the wire. UDP is connection-less which means you are not connected to the remote peer in a persistent way. Because of this you have to supply the address and port of the remote peer when sending data.

  You can send data to ipv4 or ipv6 addresses, which also include multicast addresses.

  Please consult the documentation for more information on datagram sockets.

  Author:
    Norman Maurer

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `DatagramSocket` | `blockMulticastGroup(String multicastAddress, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address and notifies the `Handler` once the operation completes.
    `DatagramSocket` | `blockMulticastGroup(String multicastAddress, String networkInterface, String sourceToBlock, Handler<AsyncResult<DatagramSocket>> handler)` Block the given address for the given multicast address on the given network interface and notifies the `Handler` once the operation completes.
    `void` | `close()` Closes the `DatagramSocket`.
    `void` | `close(Handler<AsyncResult<Void>> handler)` Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
    `DatagramSocket` | `endHandler(Handler<Void> endHandler)` Set an end handler.
    `DatagramSocket` | `exceptionHandler(Handler<Throwable> handler)` Set an exception handler on the read stream.
    `DatagramSocket` | `handler(Handler<DatagramPacket> handler)` Set a data handler.
    `DatagramSocket` | `listen(int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Start listening on the given port and host.
    `DatagramSocket` | `listenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it.
    `DatagramSocket` | `listenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Joins a multicast group and listens for packets send to it on the given network interface.
    `SocketAddress` | `localAddress()` Return the `SocketAddress` to which this `DatagramSocket` is bound.
    `DatagramSocket` | `pause()` Pause the `ReadSupport`.
    `DatagramSocket` | `resume()` Resume reading.
    `DatagramSocket` | `send(Buffer packet, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `Buffer` to the `SocketAddress`.
    `DatagramSocket` | `send(String str, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using UTF8 encoding.
    `DatagramSocket` | `send(String str, String enc, int port, String host, Handler<AsyncResult<DatagramSocket>> handler)` Write the given `String` to the `SocketAddress` using the given encoding.
    `WriteStream<Buffer>` | `sender(int port, String host)` Returns a `WriteStream<Buffer>` able to send `Buffer` to the `SocketAddress`.
    `DatagramSocket` | `unlistenMulticastGroup(String multicastAddress, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it.
    `DatagramSocket` | `unlistenMulticastGroup(String multicastAddress, String networkInterface, String source, Handler<AsyncResult<DatagramSocket>> handler)` Leaves a multicast group and stops listening for packets send to it on the given network interface.

    - ### Methods inherited from interface io.vertx.core.metrics.Measured

      `isMetricsEnabled`

- - ### Method Detail

    - #### send

          DatagramSocket send(Buffer packet,
                              int port,
                              String host,
                              Handler<AsyncResult<DatagramSocket>> handler)

      Write the given `Buffer` to the `SocketAddress`. The `Handler` will be notified once the write completes.
      Parameters:
        `packet` - the `Buffer` to write
        `port` - the host port of the remote peer
        `host` - the host address of the remote peer
        `handler` - the `Handler` to notify once the write completes.
      Returns:
        a reference to this, so the API can be used fluently

    - #### sender

          WriteStream<Buffer> sender(int port,
                                     String host)

      Returns a `WriteStream<Buffer>` able to send `Buffer` to the `SocketAddress`.
      Parameters:
        `port` - the port of the remote peer
        `host` - the host address of the remote peer
      Returns:
        the write stream for sending packets

    - #### send

          DatagramSocket send(String str,
                              int port,
                              String host,
                              Handler<AsyncResult<DatagramSocket>> handler)

      Write the given `String` to the `SocketAddress` using UTF8 encoding. The `Handler` will be notified once the write completes.
      Parameters:
        `str` - the `String` to write
        `port` - the host port of the remote peer
        `host` - the host address of the remote peer
        `handler` - the `Handler` to notify once the write completes.
      Returns:
        a reference to this, so the API can be used fluently

    - #### send

          DatagramSocket send(String str,
                              String enc,
                              int port,
                              String host,
                              Handler<AsyncResult<DatagramSocket>> handler)

      Write the given `String` to the `SocketAddress` using the given encoding. The `Handler` will be notified once the write completes.
      Parameters:
        `str` - the `String` to write
        `enc` - the charset used for encoding
        `port` - the host port of the remote peer
        `host` - the host address of the remote peer
        `handler` - the `Handler` to notify once the write completes.
      Returns:
        a reference to this, so the API can be used fluently

    - #### close

          void close(Handler<AsyncResult<Void>> handler)

      Closes the `DatagramSocket` implementation asynchronous and notifies the handler once done.
      Parameters:
        `handler` - the handler to notify once complete

    - #### close

          void close()

      Closes the `DatagramSocket`. The close itself is asynchronous.

    - #### localAddress

          SocketAddress localAddress()

      Return the `SocketAddress` to which this `DatagramSocket` is bound.
      Returns:
        the socket address

    - #### listenMulticastGroup

          DatagramSocket listenMulticastGroup(String multicastAddress,
                                              Handler<AsyncResult<DatagramSocket>> handler)

      Joins a multicast group and listens for packets send to it. The `Handler` is notified once the operation completes.
      Parameters:
        `multicastAddress` - the address of the multicast group to join
        `handler` - then handler to notify once the operation completes
      Returns:
        a reference to this, so the API can be used fluently

    - #### listenMulticastGroup

          DatagramSocket listenMulticastGroup(String multicastAddress,
                                              String networkInterface,
                                              String source,
                                              Handler<AsyncResult<DatagramSocket>> handler)

      Joins a multicast group and listens for packets send to it on the given network interface. The `Handler` is notified once the operation completes.
      Parameters:
        `multicastAddress` - the address of the multicast group to join
        `networkInterface` - the network interface on which to listen for packets.
        `source` - the address of the source for which we will listen for multicast packets
        `handler` - then handler to notify once the operation completes
      Returns:
        a reference to this, so the API can be used fluently

    - #### unlistenMulticastGroup

          DatagramSocket unlistenMulticastGroup(String multicastAddress,
                                                Handler<AsyncResult<DatagramSocket>> handler)

      Leaves a multicast group and stops listening for packets send to it. The `Handler` is notified once the operation completes.
      Parameters:
        `multicastAddress` - the address of the multicast group to leave
        `handler` - then handler to notify once the operation completes
      Returns:
        a reference to this, so the API can be used fluently

    - #### unlistenMulticastGroup

          DatagramSocket unlistenMulticastGroup(String multicastAddress,
                                                String networkInterface,
                                                String source,
                                                Handler<AsyncResult<DatagramSocket>> handler)

      Leaves a multicast group and stops listening for packets send to it on the given network interface. The `Handler` is notified once the operation completes.
      Parameters:
        `multicastAddress` - the address of the multicast group to join
        `networkInterface` - the network interface on which to listen for packets.
        `source` - the address of the source for which we will listen for multicast packets
        `handler` - the handler to notify once the operation completes
      Returns:
        a reference to this, so the API can be used fluently

    - #### blockMulticastGroup

          DatagramSocket blockMulticastGroup(String multicastAddress,
                                             String sourceToBlock,
                                             Handler<AsyncResult<DatagramSocket>> handler)

      Block the given address for the given multicast address and notifies the `Handler` once the operation completes.
      Parameters:
        `multicastAddress` - the address for which you want to block the source address
        `sourceToBlock` - the source address which should be blocked. You will not receive an multicast packets for it anymore.
        `handler` - the handler to notify once the operation completes
      Returns:
        a reference to this, so the API can be used fluently

    - #### blockMulticastGroup

          DatagramSocket blockMulticastGroup(String multicastAddress,
                                             String networkInterface,
                                             String sourceToBlock,
                                             Handler<AsyncResult<DatagramSocket>> handler)

      Block the given address for the given multicast address on the given network interface and notifies the `Handler` once the operation completes.
      Parameters:
        `multicastAddress` - the address for which you want to block the source address
        `networkInterface` - the network interface on which the blocking should occur.
        `sourceToBlock` - the source address which should be blocked. You will not receive an multicast packets for it anymore.
        `handler` - the handler to notify once the operation completes
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          DatagramSocket listen(int port,
                                String host,
                                Handler<AsyncResult<DatagramSocket>> handler)

      Start listening on the given port and host. The handler will be called when the socket is listening.
      Parameters:
        `port` - the port to listen on
        `host` - the host to listen on
        `handler` - the handler will be called when listening
      Returns:
        a reference to this, so the API can be used fluently

    - #### pause

          DatagramSocket pause()

      Description copied from interface: `ReadStream`
      Pause the `ReadSupport`. While it's paused, no data will be sent to the `dataHandler`
      Specified by:
        `pause` in interface `ReadStream<DatagramPacket>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### resume

          DatagramSocket resume()

      Description copied from interface: `ReadStream`
      Resume reading. If the `ReadSupport` has been paused, reading will recommence on it.
      Specified by:
        `resume` in interface `ReadStream<DatagramPacket>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### endHandler

          DatagramSocket endHandler(Handler<Void> endHandler)

      Description copied from interface: `ReadStream`
      Set an end handler. Once the stream has ended, and there is no more data to be read, this handler will be called.
      Specified by:
        `endHandler` in interface `ReadStream<DatagramPacket>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### handler

          DatagramSocket handler(Handler<DatagramPacket> handler)

      Description copied from interface: `ReadStream`
      Set a data handler. As data is read, the handler will be called with the data.
      Specified by:
        `handler` in interface `ReadStream<DatagramPacket>`
      Returns:
        a reference to this, so the API can be used fluently

    - #### exceptionHandler

          DatagramSocket exceptionHandler(Handler<Throwable> handler)

      Description copied from interface: `ReadStream`
      Set an exception handler on the read stream.
      Specified by:
        `exceptionHandler` in interface `ReadStream<DatagramPacket>`
      Specified by:
        `exceptionHandler` in interface `StreamBase`
      Parameters:
        `handler` - the exception handler
      Returns:
        a reference to this, so the API can be used fluently

Copyright © 2018 Eclipse. All rights reserved.