io.vertx.rxjava.mqtt

## Class MqttServer

- java.lang.Object
- - io.vertx.rxjava.mqtt.MqttServer

-     public class MqttServer
      extends Object

  An MQTT server

  You can accept incoming MQTT connection requests providing a `endpointHandler(io.vertx.core.Handler<io.vertx.rxjava.mqtt.MqttEndpoint>)`. As the requests arrive, the handler will be called with an instance of `MqttEndpoint` in order to manage the communication with the remote MQTT client.

  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 TypeArg<MqttServer>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MqttServer(MqttServer delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `actualPort()` The actual port the server is listening on.
    `void` | `close()` Close the server.
    `void` | `close(Handler<AsyncResult<Void>> completionHandler)` Close the server supplying an handler that will be called when the server is actually closed (or has failed).
    `static MqttServer` | `create(Vertx vertx)` Return an MQTT server instance using default options
    `static MqttServer` | `create(Vertx vertx, MqttServerOptions options)` Return an MQTT server instance
    `MqttServer` | `endpointHandler(Handler<MqttEndpoint> handler)` Set the endpoint handler for the server.
    `MqttServer` | `getDelegate()`
    `MqttServer` | `listen()` Start the server listening for incoming connections using the specified options through the constructor
    `MqttServer` | `listen(Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections using the specified options through the constructor
    `MqttServer` | `listen(int port)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `MqttServer` | `listen(int port, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `MqttServer` | `listen(int port, String host)` Start the server listening for incoming connections on the port and host specified
    `MqttServer` | `listen(int port, String host, Handler<AsyncResult<MqttServer>> listenHandler)` Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor
    `static MqttServer` | `newInstance(MqttServer arg)`
    `rx.Single<Void>` | `rxClose()` Close the server supplying an handler that will be called when the server is actually closed (or has failed).
    `rx.Single<MqttServer>` | `rxListen()` Start the server listening for incoming connections using the specified options through the constructor
    `rx.Single<MqttServer>` | `rxListen(int port)` Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host.
    `rx.Single<MqttServer>` | `rxListen(int port, String host)` Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor

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

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final TypeArg<MqttServer> __TYPE_ARG

  - ### Constructor Detail

    - #### MqttServer

          public MqttServer(MqttServer delegate)

  - ### Method Detail

    - #### getDelegate

          public MqttServer getDelegate()

    - #### create

          public static MqttServer create(Vertx vertx,
                                          MqttServerOptions options)

      Return an MQTT server instance
      Parameters:
        `vertx` - Vert.x instance
        `options` - MQTT server options
      Returns:
        MQTT server instance

    - #### create

          public static MqttServer create(Vertx vertx)

      Return an MQTT server instance using default options
      Parameters:
        `vertx` - Vert.x instance
      Returns:
        MQTT server instance

    - #### listen

          public MqttServer listen()

      Start the server listening for incoming connections using the specified options through the constructor
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          public MqttServer listen(int port,
                                   String host)

      Start the server listening for incoming connections on the port and host specified
      Parameters:
        `port` - the port to listen on
        `host` - the host to listen on
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          public MqttServer listen(int port,
                                   String host,
                                   Handler<AsyncResult<MqttServer>> listenHandler)

      Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor
      Parameters:
        `port` - the port to listen on
        `host` - the host to listen on
        `listenHandler` - handler called when the asynchronous listen call ends
      Returns:
        a reference to this, so the API can be used fluently

    - #### rxListen

          public rx.Single<MqttServer> rxListen(int port,
                                                String host)

      Start the server listening for incoming connections on the port and host specified It ignores any options specified through the constructor
      Parameters:
        `port` - the port to listen on
        `host` - the host to listen on
      Returns:

    - #### listen

          public MqttServer listen(int port)

      Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host. It ignores any options specified through the constructor
      Parameters:
        `port` - the port to listen on
      Returns:
        a reference to this, so the API can be used fluently

    - #### listen

          public MqttServer listen(int port,
                                   Handler<AsyncResult<MqttServer>> listenHandler)

      Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host. It ignores any options specified through the constructor
      Parameters:
        `port` - the port to listen on
        `listenHandler` - handler called when the asynchronous listen call ends
      Returns:
        a reference to this, so the API can be used fluently

    - #### rxListen

          public rx.Single<MqttServer> rxListen(int port)

      Start the server listening for incoming connections on the port specified but on "0.0.0.0" as host. It ignores any options specified through the constructor
      Parameters:
        `port` - the port to listen on
      Returns:

    - #### listen

          public MqttServer listen(Handler<AsyncResult<MqttServer>> listenHandler)

      Start the server listening for incoming connections using the specified options through the constructor
      Parameters:
        `listenHandler` - handler called when the asynchronous listen call ends
      Returns:
        a reference to this, so the API can be used fluently

    - #### rxListen

          public rx.Single<MqttServer> rxListen()

      Start the server listening for incoming connections using the specified options through the constructor
      Returns:

    - #### endpointHandler

          public MqttServer endpointHandler(Handler<MqttEndpoint> handler)

      Set the endpoint handler for the server. If an MQTT client connect to the server a new MqttEndpoint instance will be created and passed to the handler
      Parameters:
        `handler` - the endpoint handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### actualPort

          public int actualPort()

      The actual port the server is listening on. This is useful if you bound the server specifying 0 as port number signifying an ephemeral port
      Returns:
        the actual port the server is listening on.

    - #### close

          public void close()

      Close the server.

      The close happens asynchronously and the server may not be closed until some time after the call has returned.

    - #### close

          public void close(Handler<AsyncResult<Void>> completionHandler)

      Close the server supplying an handler that will be called when the server is actually closed (or has failed).
      Parameters:
        `completionHandler` - the handler called on completion

    - #### rxClose

          public rx.Single<Void> rxClose()

      Close the server supplying an handler that will be called when the server is actually closed (or has failed).
      Returns:

    - #### newInstance

          public static MqttServer newInstance(MqttServer arg)

Copyright © 2017. All rights reserved.