io.vertx.reactivex.core

## Class Vertx

- java.lang.Object
- - io.vertx.reactivex.core.Vertx

- All Implemented Interfaces:
    Measured

      public class Vertx
      extends Object
      implements Measured

  The entry point into the Vert.x Core API.

  You use an instance of this class for functionality including:

  - Creating TCP clients and servers
  - Creating HTTP clients and servers
  - Creating DNS clients
  - Creating Datagram sockets
  - Setting and cancelling periodic and one-shot timers
  - Getting a reference to the event bus API
  - Getting a reference to the file system API
  - Getting a reference to the shared data API
  - Deploying and undeploying verticles

  Most functionality in Vert.x core is fairly low level.

  To create an instance of this class you can use the static factory methods: `vertx()`, `vertx()` and `clusteredVertx(io.vertx.core.VertxOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.reactivex.core.Vertx>>)`.

  Please see the user manual for more detailed usage information.

  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<Vertx>` | `__TYPE_ARG`

  - ### Constructor Summary

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

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `cancelTimer(long id)` Cancels the timer with the specified `id`.
    `void` | `close()` Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete
    `void` | `close(Handler<AsyncResult<Void>> completionHandler)` Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete
    `static void` | `clusteredVertx(VertxOptions options)` Creates a clustered instance using the specified options.
    `static void` | `clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
    `DatagramSocket` | `createDatagramSocket()` Create a datagram socket using default options
    `DatagramSocket` | `createDatagramSocket(DatagramSocketOptions options)` Create a datagram socket using the specified options
    `DnsClient` | `createDnsClient()` Create a DNS client to connect to the DNS server configured by `VertxOptions`
    `DnsClient` | `createDnsClient(DnsClientOptions options)` Create a DNS client to connect to a DNS server
    `DnsClient` | `createDnsClient(int port, String host)` Create a DNS client to connect to a DNS server at the specified host and port, with the default query timeout (5 seconds)
    `HttpClient` | `createHttpClient()` Create a HTTP/HTTPS client using default options
    `HttpClient` | `createHttpClient(HttpClientOptions options)` Create a HTTP/HTTPS client using the specified options
    `HttpServer` | `createHttpServer()` Create an HTTP/HTTPS server using default options
    `HttpServer` | `createHttpServer(HttpServerOptions options)` Create an HTTP/HTTPS server using the specified options
    `NetClient` | `createNetClient()` Create a TCP/SSL client using default options
    `NetClient` | `createNetClient(NetClientOptions options)` Create a TCP/SSL client using the specified options
    `NetServer` | `createNetServer()` Create a TCP/SSL server using default options
    `NetServer` | `createNetServer(NetServerOptions options)` Create a TCP/SSL server using the specified options
    `WorkerExecutor` | `createSharedWorkerExecutor(String name)` Like `createSharedWorkerExecutor(java.lang.String)` but with the `VertxOptions` `poolSize`.
    `WorkerExecutor` | `createSharedWorkerExecutor(String name, int poolSize)` Like `createSharedWorkerExecutor(java.lang.String)` but with the `VertxOptions` `maxExecuteTime`.
    `WorkerExecutor` | `createSharedWorkerExecutor(String name, int poolSize, long maxExecuteTime)` Like `createSharedWorkerExecutor(java.lang.String)` but with the `VertxOptions` `maxExecuteTimeUnit`.
    `WorkerExecutor` | `createSharedWorkerExecutor(String name, int poolSize, long maxExecuteTime, TimeUnit maxExecuteTimeUnit)` Create a named worker executor, the executor should be closed when it's not needed anymore to release resources. This method can be called mutiple times with the same `name`.
    `static Context` | `currentContext()` Gets the current context
    `Set<String>` | `deploymentIDs()` Return a Set of deployment IDs for the currently deployed deploymentIDs.
    `void` | `deployVerticle(String name)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
    `void` | `deployVerticle(String name, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | `deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | `deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
    `void` | `deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.
    `void` | `deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.
    `void` | `deployVerticle(Verticle verticle)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
    `void` | `deployVerticle(Verticle verticle, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | `deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
    `void` | `deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
    `boolean` | `equals(Object o)`
    `EventBus` | `eventBus()` Get the event bus object.
    `Vertx` | `exceptionHandler(Handler<Throwable> handler)` Set a default exception handler for `Context`, set on at creation.
    `<T> void` | `executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> void` | `executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `<T> void` | `executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | `executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `FileSystem` | `fileSystem()` Get the filesystem object.
    `Vertx` | `getDelegate()`
    `Context` | `getOrCreateContext()` Gets the current context, or creates one if there isn't one
    `int` | `hashCode()`
    `boolean` | `isClustered()` Is this Vert.x instance clustered?
    `boolean` | `isMetricsEnabled()` Whether the metrics are enabled for this measured object
    `boolean` | `isNativeTransportEnabled()`
    `io.netty.channel.EventLoopGroup` | `nettyEventLoopGroup()` Return the Netty EventLoopGroup used by Vert.x
    `static Vertx` | `newInstance(Vertx arg)`
    `TimeoutStream` | `periodicStream(long delay)` Returns a periodic timer as a read stream.
    `void` | `registerVerticleFactory(VerticleFactory factory)` Register a `VerticleFactory` that can be used for deploying Verticles based on an identifier.
    `void` | `runOnContext(Handler<Void> action)` Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
    `Completable` | `rxClose()` Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete
    `static Single<Vertx>` | `rxClusteredVertx(VertxOptions options)` Creates a clustered instance using the specified options.
    `Single<String>` | `rxDeployVerticle(String name)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
    `Single<String>` | `rxDeployVerticle(String name, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
    `Single<String>` | `rxDeployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.
    `Single<String>` | `rxDeployVerticle(Verticle verticle)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.
    `Single<String>` | `rxDeployVerticle(Verticle verticle, DeploymentOptions options)` Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
    `<T> Maybe<T>` | `rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)` Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
    `<T> Maybe<T>` | `rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `Completable` | `rxUndeploy(String deploymentID)` Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.
    `long` | `setPeriodic(long delay, Handler<Long> handler)` Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `long` | `setTimer(long delay, Handler<Long> handler)` Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
    `SharedData` | `sharedData()` Get the shared data object.
    `TimeoutStream` | `timerStream(long delay)` Returns a one-shot timer as a read stream.
    `String` | `toString()`
    `void` | `undeploy(String deploymentID)` Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.
    `void` | `undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.
    `void` | `unregisterVerticleFactory(VerticleFactory factory)` Unregister a `VerticleFactory`
    `Set<VerticleFactory>` | `verticleFactories()` Return the Set of currently registered verticle factories.
    `static Vertx` | `vertx()` Creates a non clustered instance using default options.
    `static Vertx` | `vertx(VertxOptions options)` Creates a non clustered instance using the specified options

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

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

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

      `newInstance`

- - ### Field Detail

    - #### __TYPE_ARG

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

  - ### Constructor Detail

    - #### Vertx

          public Vertx(Vertx delegate)

    - #### Vertx

          public Vertx(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 Vertx 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

    - #### vertx

          public static Vertx vertx()

      Creates a non clustered instance using default options.
      Returns:
        the instance

    - #### vertx

          public static Vertx vertx(VertxOptions options)

      Creates a non clustered instance using the specified options
      Parameters:
        `options` - the options to use
      Returns:
        the instance

    - #### clusteredVertx

          public static void clusteredVertx(VertxOptions options,
                                            Handler<AsyncResult<Vertx>> resultHandler)

      Creates a clustered instance using the specified options.

      The instance is created asynchronously and the resultHandler is called with the result when it is ready.

      Parameters:
        `options` - the options to use
        `resultHandler` - the result handler that will receive the result

    - #### clusteredVertx

          public static void clusteredVertx(VertxOptions options)

      Creates a clustered instance using the specified options.

      The instance is created asynchronously and the resultHandler is called with the result when it is ready.

      Parameters:
        `options` - the options to use

    - #### rxClusteredVertx

          public static Single<Vertx> rxClusteredVertx(VertxOptions options)

      Creates a clustered instance using the specified options.

      The instance is created asynchronously and the resultHandler is called with the result when it is ready.

      Parameters:
        `options` - the options to use
      Returns:

    - #### currentContext

          public static Context currentContext()

      Gets the current context
      Returns:
        The current context or `null` if there is no current context

    - #### getOrCreateContext

          public Context getOrCreateContext()

      Gets the current context, or creates one if there isn't one
      Returns:
        The current context (created if didn't exist)

    - #### createNetServer

          public NetServer createNetServer(NetServerOptions options)

      Create a TCP/SSL server using the specified options
      Parameters:
        `options` - the options to use
      Returns:
        the server

    - #### createNetServer

          public NetServer createNetServer()

      Create a TCP/SSL server using default options
      Returns:
        the server

    - #### createNetClient

          public NetClient createNetClient(NetClientOptions options)

      Create a TCP/SSL client using the specified options
      Parameters:
        `options` - the options to use
      Returns:
        the client

    - #### createNetClient

          public NetClient createNetClient()

      Create a TCP/SSL client using default options
      Returns:
        the client

    - #### createHttpServer

          public HttpServer createHttpServer(HttpServerOptions options)

      Create an HTTP/HTTPS server using the specified options
      Parameters:
        `options` - the options to use
      Returns:
        the server

    - #### createHttpServer

          public HttpServer createHttpServer()

      Create an HTTP/HTTPS server using default options
      Returns:
        the server

    - #### createHttpClient

          public HttpClient createHttpClient(HttpClientOptions options)

      Create a HTTP/HTTPS client using the specified options
      Parameters:
        `options` - the options to use
      Returns:
        the client

    - #### createHttpClient

          public HttpClient createHttpClient()

      Create a HTTP/HTTPS client using default options
      Returns:
        the client

    - #### createDatagramSocket

          public DatagramSocket createDatagramSocket(DatagramSocketOptions options)

      Create a datagram socket using the specified options
      Parameters:
        `options` - the options to use
      Returns:
        the socket

    - #### createDatagramSocket

          public DatagramSocket createDatagramSocket()

      Create a datagram socket using default options
      Returns:
        the socket

    - #### fileSystem

          public FileSystem fileSystem()

      Get the filesystem object. There is a single instance of FileSystem per Vertx instance.
      Returns:
        the filesystem object

    - #### eventBus

          public EventBus eventBus()

      Get the event bus object. There is a single instance of EventBus per Vertx instance.
      Returns:
        the event bus object

    - #### createDnsClient

          public DnsClient createDnsClient(int port,
                                           String host)

      Create a DNS client to connect to a DNS server at the specified host and port, with the default query timeout (5 seconds)

      Parameters:
        `port` - the port
        `host` - the host
      Returns:
        the DNS client

    - #### createDnsClient

          public DnsClient createDnsClient()

      Create a DNS client to connect to the DNS server configured by `VertxOptions`

      DNS client takes the first configured resolver address provided by }

      Returns:
        the DNS client

    - #### createDnsClient

          public DnsClient createDnsClient(DnsClientOptions options)

      Create a DNS client to connect to a DNS server
      Parameters:
        `options` - the client options
      Returns:
        the DNS client

    - #### sharedData

          public SharedData sharedData()

      Get the shared data object. There is a single instance of SharedData per Vertx instance.
      Returns:
        the shared data object

    - #### setTimer

          public long setTimer(long delay,
                               Handler<Long> handler)

      Set a one-shot timer to fire after `delay` milliseconds, at which point `handler` will be called with the id of the timer.
      Parameters:
        `delay` - the delay in milliseconds, after which the timer will fire
        `handler` - the handler that will be called with the timer ID when the timer fires
      Returns:
        the unique ID of the timer

    - #### timerStream

          public TimeoutStream timerStream(long delay)

      Returns a one-shot timer as a read stream. The timer will be fired after `delay` milliseconds after the has been called.
      Parameters:
        `delay` - the delay in milliseconds, after which the timer will fire
      Returns:
        the timer stream

    - #### setPeriodic

          public long setPeriodic(long delay,
                                  Handler<Long> handler)

      Set a periodic timer to fire every `delay` milliseconds, at which point `handler` will be called with the id of the timer.
      Parameters:
        `delay` - the delay in milliseconds, after which the timer will fire
        `handler` - the handler that will be called with the timer ID when the timer fires
      Returns:
        the unique ID of the timer

    - #### periodicStream

          public TimeoutStream periodicStream(long delay)

      Returns a periodic timer as a read stream. The timer will be fired every `delay` milliseconds after the has been called.
      Parameters:
        `delay` - the delay in milliseconds, after which the timer will fire
      Returns:
        the periodic stream

    - #### cancelTimer

          public boolean cancelTimer(long id)

      Cancels the timer with the specified `id`.
      Parameters:
        `id` - The id of the timer to cancel
      Returns:
        true if the timer was successfully cancelled, or false if the timer does not exist.

    - #### runOnContext

          public void runOnContext(Handler<Void> action)

      Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
      Parameters:
        `action` - - a handler representing the action to execute

    - #### close

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

      Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete
      Parameters:
        `completionHandler` - The handler will be notified when the close is complete.

    - #### close

          public void close()

      Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete

    - #### rxClose

          public Completable rxClose()

      Like `close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` but the completionHandler will be called when the close is complete
      Returns:

    - #### deployVerticle

          public void deployVerticle(String name,
                                     Handler<AsyncResult<String>> completionHandler)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.

      If the deployment is successful the result will contain a String representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

      Parameters:
        `name` - The identifier
        `completionHandler` - a handler which will be notified when the deployment is complete

    - #### deployVerticle

          public void deployVerticle(String name)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.

      If the deployment is successful the result will contain a String representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

      Parameters:
        `name` - The identifier

    - #### rxDeployVerticle

          public Single<String> rxDeployVerticle(String name)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.

      If the deployment is successful the result will contain a String representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

      Parameters:
        `name` - The identifier
      Returns:

    - #### deployVerticle

          public void deployVerticle(String name,
                                     DeploymentOptions options,
                                     Handler<AsyncResult<String>> completionHandler)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
      Parameters:
        `name` - the name
        `options` - the deployment options.
        `completionHandler` - a handler which will be notified when the deployment is complete

    - #### deployVerticle

          public void deployVerticle(String name,
                                     DeploymentOptions options)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
      Parameters:
        `name` - the name
        `options` - the deployment options.

    - #### rxDeployVerticle

          public Single<String> rxDeployVerticle(String name,
                                                 DeploymentOptions options)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
      Parameters:
        `name` - the name
        `options` - the deployment options.
      Returns:

    - #### undeploy

          public void undeploy(String deploymentID,
                               Handler<AsyncResult<Void>> completionHandler)

      Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.
      Parameters:
        `deploymentID` - the deployment ID
        `completionHandler` - a handler which will be notified when the undeployment is complete

    - #### undeploy

          public void undeploy(String deploymentID)

      Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.
      Parameters:
        `deploymentID` - the deployment ID

    - #### rxUndeploy

          public Completable rxUndeploy(String deploymentID)

      Like `#undeploy(String)` but the completionHandler will be notified when the undeployment is complete.
      Parameters:
        `deploymentID` - the deployment ID
      Returns:

    - #### deploymentIDs

          public Set<String> deploymentIDs()

      Return a Set of deployment IDs for the currently deployed deploymentIDs.
      Returns:
        Set of deployment IDs

    - #### isClustered

          public boolean isClustered()

      Is this Vert.x instance clustered?
      Returns:
        true if clustered

    - #### executeBlocking

          public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                          boolean ordered,
                                          Handler<AsyncResult<T>> resultHandler)

      Safely execute some blocking code.

      Executes the blocking code in the handler `blockingCodeHandler` using a thread from the worker pool.

      When the code is complete the handler `resultHandler` will be called with the result on the original context (e.g. on the original event loop of the caller).

      A `Future` instance is passed into `blockingCodeHandler`. When the blocking code successfully completes, the handler should call the `Promise.complete(T)` or `Promise.complete(T)` method, or the `Promise.fail(java.lang.Throwable)` method if it failed.

      In the `blockingCodeHandler` the current context remains the original context and therefore any task scheduled in the `blockingCodeHandler` will be executed on the this context and not on the worker thread.

      The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.

      When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.

      Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or `Context.runOnContext(io.vertx.core.Handler<java.lang.Void>)`

      Parameters:
        `blockingCodeHandler` - handler representing the blocking code to run
        `ordered` - if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
        `resultHandler` - handler that will be called when the blocking code is complete

    - #### executeBlocking

          public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                          boolean ordered)

      Safely execute some blocking code.

      Executes the blocking code in the handler `blockingCodeHandler` using a thread from the worker pool.

      When the code is complete the handler `resultHandler` will be called with the result on the original context (e.g. on the original event loop of the caller).

      A `Future` instance is passed into `blockingCodeHandler`. When the blocking code successfully completes, the handler should call the `Promise.complete(T)` or `Promise.complete(T)` method, or the `Promise.fail(java.lang.Throwable)` method if it failed.

      In the `blockingCodeHandler` the current context remains the original context and therefore any task scheduled in the `blockingCodeHandler` will be executed on the this context and not on the worker thread.

      The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.

      When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.

      Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or `Context.runOnContext(io.vertx.core.Handler<java.lang.Void>)`

      Parameters:
        `blockingCodeHandler` - handler representing the blocking code to run
        `ordered` - if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees

    - #### rxExecuteBlocking

          public <T> Maybe<T> rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
                                                boolean ordered)

      Safely execute some blocking code.

      Executes the blocking code in the handler `blockingCodeHandler` using a thread from the worker pool.

      When the code is complete the handler `resultHandler` will be called with the result on the original context (e.g. on the original event loop of the caller).

      A `Future` instance is passed into `blockingCodeHandler`. When the blocking code successfully completes, the handler should call the `Promise.complete(T)` or `Promise.complete(T)` method, or the `Promise.fail(java.lang.Throwable)` method if it failed.

      In the `blockingCodeHandler` the current context remains the original context and therefore any task scheduled in the `blockingCodeHandler` will be executed on the this context and not on the worker thread.

      The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.

      When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.

      Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or `Context.runOnContext(io.vertx.core.Handler<java.lang.Void>)`

      Parameters:
        `blockingCodeHandler` - handler representing the blocking code to run
        `ordered` - if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
      Returns:

    - #### executeBlocking

          public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                          Handler<AsyncResult<T>> resultHandler)

      Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
      Parameters:
        `blockingCodeHandler` -
        `resultHandler` -

    - #### executeBlocking

          public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler)

      Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
      Parameters:
        `blockingCodeHandler` -

    - #### rxExecuteBlocking

          public <T> Maybe<T> rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)

      Like `executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>)` called with ordered = true.
      Parameters:
        `blockingCodeHandler` -
      Returns:

    - #### createSharedWorkerExecutor

          public WorkerExecutor createSharedWorkerExecutor(String name)

      Like `createSharedWorkerExecutor(java.lang.String)` but with the `VertxOptions` `poolSize`.
      Parameters:
        `name` -
      Returns:

    - #### createSharedWorkerExecutor

          public WorkerExecutor createSharedWorkerExecutor(String name,
                                                           int poolSize)

      Like `createSharedWorkerExecutor(java.lang.String)` but with the `VertxOptions` `maxExecuteTime`.
      Parameters:
        `name` -
        `poolSize` -
      Returns:

    - #### createSharedWorkerExecutor

          public WorkerExecutor createSharedWorkerExecutor(String name,
                                                           int poolSize,
                                                           long maxExecuteTime)

      Like `createSharedWorkerExecutor(java.lang.String)` but with the `VertxOptions` `maxExecuteTimeUnit`.
      Parameters:
        `name` -
        `poolSize` -
        `maxExecuteTime` -
      Returns:

    - #### createSharedWorkerExecutor

          public WorkerExecutor createSharedWorkerExecutor(String name,
                                                           int poolSize,
                                                           long maxExecuteTime,
                                                           TimeUnit maxExecuteTimeUnit)

      Create a named worker executor, the executor should be closed when it's not needed anymore to release resources.

      This method can be called mutiple times with the same `name`. Executors with the same name will share the same worker pool. The worker pool size , max execute time and unit of max execute time are set when the worker pool is created and won't change after.

      The worker pool is released when all the `WorkerExecutor` sharing the same name are closed.

      Parameters:
        `name` - the name of the worker executor
        `poolSize` - the size of the pool
        `maxExecuteTime` - the value of max worker execute time
        `maxExecuteTimeUnit` - the value of unit of max worker execute time
      Returns:
        the named worker executor

    - #### isNativeTransportEnabled

          public boolean isNativeTransportEnabled()

      Returns:
        whether the native transport is used

    - #### exceptionHandler

          public Vertx exceptionHandler(Handler<Throwable> handler)

      Set a default exception handler for `Context`, set on at creation.
      Parameters:
        `handler` - the exception handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### deployVerticle

          public void deployVerticle(Verticle verticle,
                                     Handler<AsyncResult<String>> completionHandler)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.

      If the deployment is successful the result will contain a string representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

      Parameters:
        `verticle` - the verticle instance to deploy
        `completionHandler` - a handler which will be notified when the deployment is complete

    - #### deployVerticle

          public void deployVerticle(Verticle verticle)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.

      If the deployment is successful the result will contain a string representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

      Parameters:
        `verticle` - the verticle instance to deploy

    - #### rxDeployVerticle

          public Single<String> rxDeployVerticle(Verticle verticle)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but the completionHandler will be notified when the deployment is complete.

      If the deployment is successful the result will contain a string representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

      Parameters:
        `verticle` - the verticle instance to deploy
      Returns:

    - #### deployVerticle

          public void deployVerticle(Verticle verticle,
                                     DeploymentOptions options,
                                     Handler<AsyncResult<String>> completionHandler)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
      Parameters:
        `verticle` - the verticle instance to deploy
        `options` - the deployment options.
        `completionHandler` - a handler which will be notified when the deployment is complete

    - #### deployVerticle

          public void deployVerticle(Verticle verticle,
                                     DeploymentOptions options)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
      Parameters:
        `verticle` - the verticle instance to deploy
        `options` - the deployment options.

    - #### rxDeployVerticle

          public Single<String> rxDeployVerticle(Verticle verticle,
                                                 DeploymentOptions options)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `DeploymentOptions` are provided to configure the deployment.
      Parameters:
        `verticle` - the verticle instance to deploy
        `options` - the deployment options.
      Returns:

    - #### deployVerticle

          public void deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
                                     DeploymentOptions options,
                                     Handler<AsyncResult<String>> completionHandler)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.

      The supplier will be invoked as many times as `DeploymentOptions`. It must not return the same instance twice.

      Note that the supplier will be invoked on the caller thread.

      Parameters:
        `verticleSupplier` -
        `options` -
        `completionHandler` -

    - #### deployVerticle

          public void deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
                                     DeploymentOptions options)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.

      The supplier will be invoked as many times as `DeploymentOptions`. It must not return the same instance twice.

      Note that the supplier will be invoked on the caller thread.

      Parameters:
        `verticleSupplier` -
        `options` -

    - #### rxDeployVerticle

          public Single<String> rxDeployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
                                                 DeploymentOptions options)

      Like `deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>)` but `Verticle` instance is created by invoking the `verticleSupplier`.

      The supplier will be invoked as many times as `DeploymentOptions`. It must not return the same instance twice.

      Note that the supplier will be invoked on the caller thread.

      Parameters:
        `verticleSupplier` -
        `options` -
      Returns:

    - #### registerVerticleFactory

          public void registerVerticleFactory(VerticleFactory factory)

      Register a `VerticleFactory` that can be used for deploying Verticles based on an identifier.
      Parameters:
        `factory` - the factory to register

    - #### unregisterVerticleFactory

          public void unregisterVerticleFactory(VerticleFactory factory)

      Unregister a `VerticleFactory`
      Parameters:
        `factory` - the factory to unregister

    - #### verticleFactories

          public Set<VerticleFactory> verticleFactories()

      Return the Set of currently registered verticle factories.
      Returns:
        the set of verticle factories

    - #### nettyEventLoopGroup

          public io.netty.channel.EventLoopGroup nettyEventLoopGroup()

      Return the Netty EventLoopGroup used by Vert.x
      Returns:
        the EventLoopGroup

    - #### newInstance

          public static Vertx newInstance(Vertx arg)

Copyright © 2022 Eclipse. All rights reserved.