io.vertx.rxjava3.core.net

## Class NetClient

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

- All Implemented Interfaces:
    Measured

      public class NetClient
      extends Object
      implements 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 and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<NetClient>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `NetClient(NetClient delegate)`
    `NetClient(Object delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `Completable` | `close()` Close the client.
    `Single<NetSocket>` | `connect(int port, String host)` Open a connection to a server at the specific `port` and `host`.
    `Single<NetSocket>` | `connect(int port, String host, String serverName)` Open a connection to a server at the specific `port` and `host`.
    `Single<NetSocket>` | `connect(SocketAddress remoteAddress)` Open a connection to a server at the specific `remoteAddress`.
    `Single<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 the client.
    `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(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`.
    `String` | `toString()`

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

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

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

      `newInstance`

- - ### 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`

    - #### 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 Single<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 reference to this, so the API can be used fluently

    - #### 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 reference to this, so the API can be used fluently

    - #### connect

          public Single<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 reference to this, so the API can be used fluently

    - #### 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 reference to this, so the API can be used fluently

    - #### connect

          public Single<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 reference to this, so the API can be used fluently

    - #### 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 reference to this, so the API can be used fluently

    - #### connect

          public Single<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 reference to this, so the API can be used fluently

    - #### 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 reference to this, so the API can be used fluently

    - #### close

          public Completable close()

      Close the client.

      Any sockets which have not been closed manually will be closed here. The close is asynchronous and may not complete until some time after the method has returned.

      Returns:

    - #### rxClose

          public Completable rxClose()

      Close the client.

      Any sockets which have not been closed manually will be closed here. The close is asynchronous and may not complete until some time after the method has returned.

      Returns:

    - #### newInstance

          public static NetClient newInstance(NetClient arg)

Copyright © 2021 Eclipse. All rights reserved.