io.vertx.rxjava.core

## Class Vertx

- java.lang.Object
- - io.vertx.rxjava.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.rxjava.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.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `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()` Stop the the Vertx instance and release any resources held by it.
    `void` | `close(Handler<AsyncResult<Void>> completionHandler)` Like `Vertx` but the completionHandler will be called when the close is complete
    `rx.Observable<Void>` | `closeObservable()` Like `Vertx` but the completionHandler will be called when the close is complete
    `static void` | `clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler)` Creates a clustered instance using the specified options.
    `static rx.Observable<Vertx>` | `clusteredVertxObservable(VertxOptions options)` 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(int port, String host)` Create a DNS client to connect to a DNS server at the specified host and port
    `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
    `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)` Deploy a verticle instance given a name.
    `void` | `deployVerticle(String name, DeploymentOptions options)` Like `Vertx` but `DeploymentOptions` are provided to configure the deployment.
    `void` | `deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler)` Like `Vertx` but `DeploymentOptions` are provided to configure the deployment.
    `void` | `deployVerticle(String name, Handler<AsyncResult<String>> completionHandler)` Like `Vertx` but the completionHandler will be notified when the deployment is complete.
    `rx.Observable<String>` | `deployVerticleObservable(String name)` Like `Vertx` but the completionHandler will be notified when the deployment is complete.
    `rx.Observable<String>` | `deployVerticleObservable(String name, DeploymentOptions options)` Like `Vertx` but `DeploymentOptions` are provided to configure the deployment.
    `EventBus` | `eventBus()` Get the event bus object.
    `<T> void` | `executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
    `<T> void` | `executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Like `Vertx` called with ordered = true.
    `<T> rx.Observable<T>` | `executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)` Like `Vertx` called with ordered = true.
    `<T> rx.Observable<T>` | `executeBlockingObservable(Handler<Future<T>> blockingCodeHandler, boolean ordered)` Safely execute some blocking code.
    `FileSystem` | `fileSystem()` Get the filesystem object.
    `Object` | `getDelegate()`
    `Context` | `getOrCreateContext()` Gets the current context, or creates one if there isn't one
    `boolean` | `isClustered()` Is this Vert.x instance clustered?
    `boolean` | `isMetricsEnabled()` Whether the metrics are enabled for this measured object
    `static Vertx` | `newInstance(Vertx arg)`
    `TimeoutStream` | `periodicStream(long delay)` Returns a periodic timer as a read stream.
    `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.
    `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.
    `void` | `undeploy(String deploymentID)` Undeploy a verticle deployment.
    `void` | `undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler)` Like `Vertx` but the completionHandler will be notified when the undeployment is complete.
    `rx.Observable<Void>` | `undeployObservable(String deploymentID)` Like `Vertx` but the completionHandler will be notified when the undeployment is complete.
    `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, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

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

      `newInstance`

- - ### Constructor Detail

    - #### Vertx

          public Vertx(Vertx delegate)

  - ### Method Detail

    - #### getDelegate

          public Object 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 the 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

    - #### clusteredVertxObservable

          public static rx.Observable<Vertx> clusteredVertxObservable(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 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
      Parameters:
        `port` - the port
        `host` - the host
      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()

      Stop the the Vertx instance and release any resources held by it.

      The instance cannot be used after it has been closed.

      The actual close is asynchronous and may not complete until after the call has returned.

    - #### close

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

      Like `Vertx` but the completionHandler will be called when the close is complete
      Parameters:
        `completionHandler` - The handler will be notified when the close is complete.

    - #### closeObservable

          public rx.Observable<Void> closeObservable()

      Like `Vertx` but the completionHandler will be called when the close is complete
      Returns:

    - #### deployVerticle

          public void deployVerticle(String name)

      Deploy a verticle instance given a name.

      Given the name, Vert.x selects a instance to use to instantiate the verticle.

      For the rules on how factories are selected please consult the user manual.

      Parameters:
        `name` - the name.

    - #### deployVerticle

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

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

    - #### deployVerticleObservable

          public rx.Observable<String> deployVerticleObservable(String name)

      Like `Vertx` 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)

      Like `Vertx` but `DeploymentOptions` are provided to configure the deployment.
      Parameters:
        `name` - the name
        `options` - the deployment options.

    - #### deployVerticle

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

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

    - #### deployVerticleObservable

          public rx.Observable<String> deployVerticleObservable(String name,
                                                                DeploymentOptions options)

      Like `Vertx` but `DeploymentOptions` are provided to configure the deployment.
      Parameters:
        `name` - the name
        `options` - the deployment options.
      Returns:

    - #### undeploy

          public void undeploy(String deploymentID)

      Undeploy a verticle deployment.

      The actual undeployment happens asynchronously and may not complete until after the method has returned.

      Parameters:
        `deploymentID` - the deployment ID

    - #### undeploy

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

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

    - #### undeployObservable

          public rx.Observable<Void> undeployObservable(String deploymentID)

      Like `Vertx` 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<Future<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 `Future` or `Future` method, or the `Future` method if it failed.

      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

    - #### executeBlockingObservable

          public <T> rx.Observable<T> executeBlockingObservable(Handler<Future<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 `Future` or `Future` method, or the `Future` method if it failed.

      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<Future<T>> blockingCodeHandler,
                                          Handler<AsyncResult<T>> resultHandler)

      Like `Vertx` called with ordered = true.
      Parameters:
        `blockingCodeHandler` -
        `resultHandler` -

    - #### executeBlockingObservable

          public <T> rx.Observable<T> executeBlockingObservable(Handler<Future<T>> blockingCodeHandler)

      Like `Vertx` called with ordered = true.
      Parameters:
        `blockingCodeHandler` -
      Returns:

    - #### newInstance

          public static Vertx newInstance(Vertx arg)

Copyright © 2015. All Rights Reserved.