Package io.vertx.reactivex.core.net

## Class NetClient

- java.lang.Object
- - io.vertx.reactivex.core.net.NetClient

- All Implemented Interfaces:
    `io.vertx.lang.rx.RxDelegate`, `Measured`

      public class NetClient
      extends Object
      implements io.vertx.lang.rx.RxDelegate, Measured

  A TCP client.

  Multiple connections to different servers can be made using the same instance.

  This client supports a configurable number of connection attempts and a configurable delay between attempts.

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static io.vertx.lang.rx.TypeArg<NetClient>` | `__TYPE_ARG` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `NetClient​(NetClient delegate)` |
    `NetClient​(Object delegate)` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | `close()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Future<NetSocket>` | `connect​(int port, String host)` | Open a connection to a server at the specific `port` and `host`.
    `Future<NetSocket>` | `connect​(int port, String host, String serverName)` | Open a connection to a server at the specific `port` and `host`.
    `Future<NetSocket>` | `connect​(ConnectOptions connectOptions)` | Open a connection to a server at the specific `connectOptions`.
    `Future<NetSocket>` | `connect​(SocketAddress remoteAddress)` | Open a connection to a server at the specific `remoteAddress`.
    `Future<NetSocket>` | `connect​(SocketAddress remoteAddress, String serverName)` | Open a connection to a server at the specific `remoteAddress`.
    `boolean` | `equals​(Object o)` |
    `NetClient` | `getDelegate()` |
    `int` | `hashCode()` |
    `boolean` | `isMetricsEnabled()` | Whether the metrics are enabled for this measured object
    `static NetClient` | `newInstance​(NetClient arg)` |
    `Completable` | `rxClose()` | Close immediately (`shutdown(0, TimeUnit.SECONDS`).
    `Single<NetSocket>` | `rxConnect​(int port, String host)` | Open a connection to a server at the specific `port` and `host`.
    `Single<NetSocket>` | `rxConnect​(int port, String host, String serverName)` | Open a connection to a server at the specific `port` and `host`.
    `Single<NetSocket>` | `rxConnect​(ConnectOptions connectOptions)` | Open a connection to a server at the specific `connectOptions`.
    `Single<NetSocket>` | `rxConnect​(SocketAddress remoteAddress)` | Open a connection to a server at the specific `remoteAddress`.
    `Single<NetSocket>` | `rxConnect​(SocketAddress remoteAddress, String serverName)` | Open a connection to a server at the specific `remoteAddress`.
    `Completable` | `rxShutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Completable` | `rxShutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `Single<Boolean>` | `rxUpdateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Single<Boolean>` | `rxUpdateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Void>` | `shutdown()` | Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
    `Future<Void>` | `shutdown​(long timeout, TimeUnit unit)` | Initiate the client shutdown sequence.
    `String` | `toString()` |
    `Future<Boolean>` | `updateSSLOptions​(ClientSSLOptions options)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.
    `Future<Boolean>` | `updateSSLOptions​(ClientSSLOptions options, boolean force)` | Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<NetClient> __TYPE_ARG

  - ### Constructor Detail

    - #### NetClient

          public NetClient​(NetClient delegate)

    - #### NetClient

          public NetClient​(Object delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals​(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public NetClient getDelegate()

      Specified by:
        `getDelegate` in interface `Measured`
      Specified by:
        `getDelegate` in interface `io.vertx.lang.rx.RxDelegate`

    - #### isMetricsEnabled

          public boolean isMetricsEnabled()

      Whether the metrics are enabled for this measured object
      Specified by:
        `isMetricsEnabled` in interface `Measured`
      Returns:
        `true` if metrics are enabled

    - #### connect

          public Future<NetSocket> connect​(int port,
                                           String host)

      Open a connection to a server at the specific `port` and `host`.

      `host` can be a valid host name or IP address. The connect is done asynchronously and on success, a `NetSocket` instance is supplied via the `connectHandler` instance

      Parameters:
        `port` - the port
        `host` - the host
      Returns:
        a future notified when the socket is connected

    - #### rxConnect

          public Single<NetSocket> rxConnect​(int port,
                                             String host)

      Open a connection to a server at the specific `port` and `host`.

      `host` can be a valid host name or IP address. The connect is done asynchronously and on success, a `NetSocket` instance is supplied via the `connectHandler` instance

      Parameters:
        `port` - the port
        `host` - the host
      Returns:
        a future notified when the socket is connected

    - #### connect

          public Future<NetSocket> connect​(int port,
                                           String host,
                                           String serverName)

      Open a connection to a server at the specific `port` and `host`.

      `host` can be a valid host name or IP address. The connect is done asynchronously and on success, a `NetSocket` instance is supplied via the `connectHandler` instance

      Parameters:
        `port` - the port
        `host` - the host
        `serverName` - the SNI server name
      Returns:
        a future notified when the socket is connected

    - #### rxConnect

          public Single<NetSocket> rxConnect​(int port,
                                             String host,
                                             String serverName)

      Open a connection to a server at the specific `port` and `host`.

      `host` can be a valid host name or IP address. The connect is done asynchronously and on success, a `NetSocket` instance is supplied via the `connectHandler` instance

      Parameters:
        `port` - the port
        `host` - the host
        `serverName` - the SNI server name
      Returns:
        a future notified when the socket is connected

    - #### connect

          public Future<NetSocket> connect​(SocketAddress remoteAddress)

      Open a connection to a server at the specific `remoteAddress`.

      The connect is done asynchronously and on success, a `NetSocket` instance is supplied via the `connectHandler` instance

      Parameters:
        `remoteAddress` - the remote address
      Returns:
        a future notified when the socket is connected

    - #### rxConnect

          public Single<NetSocket> rxConnect​(SocketAddress remoteAddress)

      Open a connection to a server at the specific `remoteAddress`.

      The connect is done asynchronously and on success, a `NetSocket` instance is supplied via the `connectHandler` instance

      Parameters:
        `remoteAddress` - the remote address
      Returns:
        a future notified when the socket is connected

    - #### connect

          public Future<NetSocket> connect​(SocketAddress remoteAddress,
                                           String serverName)

      Open a connection to a server at the specific `remoteAddress`.

      The connect is done asynchronously and on success, a `NetSocket` instance is supplied via the `connectHandler` instance

      Parameters:
        `remoteAddress` - the remote address
        `serverName` - the SNI server name
      Returns:
        a future notified when the socket is connected

    - #### rxConnect

          public Single<NetSocket> rxConnect​(SocketAddress remoteAddress,
                                             String serverName)

      Open a connection to a server at the specific `remoteAddress`.

      The connect is done asynchronously and on success, a `NetSocket` instance is supplied via the `connectHandler` instance

      Parameters:
        `remoteAddress` - the remote address
        `serverName` - the SNI server name
      Returns:
        a future notified when the socket is connected

    - #### connect

          public Future<NetSocket> connect​(ConnectOptions connectOptions)

      Open a connection to a server at the specific `connectOptions`.

      The connect is done asynchronously and on success, a `NetSocket` instance is supplied via the `connectHandler` instance

      Parameters:
        `connectOptions` - the options describing how to connect to the remote server
      Returns:
        a future notified when the socket is connected

    - #### rxConnect

          public Single<NetSocket> rxConnect​(ConnectOptions connectOptions)

      Open a connection to a server at the specific `connectOptions`.

      The connect is done asynchronously and on success, a `NetSocket` instance is supplied via the `connectHandler` instance

      Parameters:
        `connectOptions` - the options describing how to connect to the remote server
      Returns:
        a future notified when the socket is connected

    - #### close

          public Future<Void> close()

      Close immediately (`shutdown(0, TimeUnit.SECONDS`).
      Returns:
        a future notified when the client is closed

    - #### rxClose

          public Completable rxClose()

      Close immediately (`shutdown(0, TimeUnit.SECONDS`).
      Returns:
        a future notified when the client is closed

    - #### shutdown

          public Future<Void> shutdown()

      Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
      Returns:
        a future completed when shutdown has completed

    - #### rxShutdown

          public Completable rxShutdown()

      Shutdown with a 30 seconds timeout (`shutdown(30, TimeUnit.SECONDS)`).
      Returns:
        a future completed when shutdown has completed

    - #### shutdown

          public Future<Void> shutdown​(long timeout,
                                       TimeUnit unit)

      Initiate the client shutdown sequence.

      Connections are taken out of service and notified the close sequence has started through `NetSocket.shutdownHandler(io.vertx.core.Handler<java.lang.Void>)`. When all connections are closed the client is closed. When the `timeout` expires, all unclosed connections are immediately closed.

      Parameters:
        `timeout` - the amount of time after which all resources are forcibly closed
        `unit` - the of the timeout
      Returns:
        a future notified when the client is closed

    - #### rxShutdown

          public Completable rxShutdown​(long timeout,
                                        TimeUnit unit)

      Initiate the client shutdown sequence.

      Connections are taken out of service and notified the close sequence has started through `NetSocket.shutdownHandler(io.vertx.core.Handler<java.lang.Void>)`. When all connections are closed the client is closed. When the `timeout` expires, all unclosed connections are immediately closed.

      Parameters:
        `timeout` - the amount of time after which all resources are forcibly closed
        `unit` - the of the timeout
      Returns:
        a future notified when the client is closed

    - #### updateSSLOptions

          public Future<Boolean> updateSSLOptions​(ClientSSLOptions options)

      Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.

      The boolean succeeded future result indicates whether the update occurred.

      Parameters:
        `options` - the new SSL options
      Returns:
        a future signaling the update success

    - #### rxUpdateSSLOptions

          public Single<Boolean> rxUpdateSSLOptions​(ClientSSLOptions options)

      Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.

      The boolean succeeded future result indicates whether the update occurred.

      Parameters:
        `options` - the new SSL options
      Returns:
        a future signaling the update success

    - #### updateSSLOptions

          public Future<Boolean> updateSSLOptions​(ClientSSLOptions options,
                                                  boolean force)

      Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.

      The `options` object is compared using its `equals` method against the existing options to prevent an update when the objects are equals since loading options can be costly, this can happen for share TCP servers. When object are equals, setting `force` to `true` forces the update.

      The boolean succeeded future result indicates whether the update occurred.

      Parameters:
        `options` - the new SSL options
        `force` - force the update when options are equals
      Returns:
        a future signaling the update success

    - #### rxUpdateSSLOptions

          public Single<Boolean> rxUpdateSSLOptions​(ClientSSLOptions options,
                                                    boolean force)

      Update the client with new SSL `options`, the update happens if the options object is valid and different from the existing options object.

      The `options` object is compared using its `equals` method against the existing options to prevent an update when the objects are equals since loading options can be costly, this can happen for share TCP servers. When object are equals, setting `force` to `true` forces the update.

      The boolean succeeded future result indicates whether the update occurred.

      Parameters:
        `options` - the new SSL options
        `force` - force the update when options are equals
      Returns:
        a future signaling the update success

    - #### newInstance

          public static NetClient newInstance​(NetClient arg)