io.vertx.rxjava.core

## Class Context

- java.lang.Object
- - io.vertx.rxjava.core.Context

-     public class Context
      extends Object

  The execution context of a `Handler` execution.

  When Vert.x provides an event to a handler or calls the start or stop methods of a `Verticle`, the execution is associated with a `Context`.

  Usually a context is an *event-loop context* and is tied to a specific event loop thread. So executions for that context always occur on that exact same event loop thread.

  In the case of worker verticles and running inline blocking code a worker context will be associated with the execution which will use a thread from the worker thread pool.

  When a handler is set by a thread associated with a specific context, the Vert.x will guarantee that when that handler is executed, that execution will be associated with the same context.

  If a handler is set by a thread not associated with a context (i.e. a non Vert.x thread). Then a new context will be created for that handler.

  In other words, a context is propagated.

  This means that when a verticle is deployed, any handlers it sets will be associated with the same context - the context of the verticle.

  This means (in the case of a standard verticle) that the verticle code will always be executed with the exact same thread, so you don't have to worry about multi-threaded acccess to the verticle state and you can code your application as single threaded.

  This class also allows arbitrary data to be `put(java.lang.String, java.lang.Object)` and `get(java.lang.String)` on the context so it can be shared easily amongst different handlers of, for example, a verticle instance.

  This class also provides `runOnContext(io.vertx.core.Handler<java.lang.Void>)` which allows an action to be executed asynchronously using the same context.

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

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `Context(Context delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `JsonObject` | `config()` If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.
    `String` | `deploymentID()` If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.
    `<T> T` | `get(String key)` Get some data from the context.
    `Object` | `getDelegate()`
    `int` | `getInstanceCount()`
    `boolean` | `isEventLoopContext()` Is the current context an event loop context?
    `boolean` | `isMultiThreadedWorkerContext()` Is the current context a multi-threaded worker context?
    `static boolean` | `isOnEventLoopThread()` Is the current thread an event thread?
    `static boolean` | `isOnVertxThread()` Is the current thread a Vert.x thread? That's either a worker thread or an event loop thread
    `static boolean` | `isOnWorkerThread()` Is the current thread a worker thread?
    `boolean` | `isWorkerContext()` Is the current context a worker context?
    `static Context` | `newInstance(Context arg)`
    `Vertx` | `owner()`
    `List<String>` | `processArgs()` The process args
    `void` | `put(String key, Object value)` Put some data in the context.
    `boolean` | `remove(String key)` Remove some data from the context.
    `void` | `runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.

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

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

- - ### Constructor Detail

    - #### Context

          public Context(Context delegate)

  - ### Method Detail

    - #### getDelegate

          public Object getDelegate()

    - #### isOnWorkerThread

          public static boolean isOnWorkerThread()

      Is the current thread a worker thread?

      NOTE! This is not always the same as calling `isWorkerContext()`. If you are running blocking code from an event loop context, then this will return true but `isWorkerContext()` will return false.

      Returns:
        true if current thread is a worker thread, false otherwise

    - #### isOnEventLoopThread

          public static boolean isOnEventLoopThread()

      Is the current thread an event thread?

      NOTE! This is not always the same as calling `Context`. If you are running blocking code from an event loop context, then this will return false but `Context` will return true.

      Returns:
        true if current thread is a worker thread, false otherwise

    - #### isOnVertxThread

          public static boolean isOnVertxThread()

      Is the current thread a Vert.x thread? That's either a worker thread or an event loop thread
      Returns:
        true if current thread is a Vert.x thread, false otherwise

    - #### runOnContext

          public void runOnContext(Handler<Void> action)

      Run the specified action asynchronously on the same context, some time after the current execution has completed.
      Parameters:
        `action` - the action to run

    - #### deploymentID

          public String deploymentID()

      If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.
      Returns:
        the deployment ID of the deployment or null if not a Verticle deployment

    - #### config

          public JsonObject config()

      If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.
      Returns:
        the configuration of the deployment or null if not a Verticle deployment

    - #### processArgs

          public List<String> processArgs()

      The process args
      Returns:

    - #### isEventLoopContext

          public boolean isEventLoopContext()

      Is the current context an event loop context?

      NOTE! when running blocking code using `Vertx` from a standard (not worker) verticle, the context will still an event loop context and this will return true.

      Returns:
        true if false otherwise

    - #### isWorkerContext

          public boolean isWorkerContext()

      Is the current context a worker context?

      NOTE! when running blocking code using `Vertx` from a standard (not worker) verticle, the context will still an event loop context and this will return false.

      Returns:
        true if the current context is a worker context, false otherwise

    - #### isMultiThreadedWorkerContext

          public boolean isMultiThreadedWorkerContext()

      Is the current context a multi-threaded worker context?
      Returns:
        true if the current context is a multi-threaded worker context, false otherwise

    - #### get

          public <T> T get(String key)

      Get some data from the context.
      Parameters:
        `key` - the key of the data
      Returns:
        the data

    - #### put

          public void put(String key,
                          Object value)

      Put some data in the context.

      This can be used to share data between different handlers that share a context

      Parameters:
        `key` - the key of the data
        `value` - the data

    - #### remove

          public boolean remove(String key)

      Remove some data from the context.
      Parameters:
        `key` - the key to remove
      Returns:
        true if removed successfully, false otherwise

    - #### owner

          public Vertx owner()

      Returns:
        The Vertx instance that created the context

    - #### getInstanceCount

          public int getInstanceCount()

      Returns:
        the number of instances of the verticle that were deployed in the deployment (if any) related to this context

    - #### newInstance

          public static Context newInstance(Context arg)

Copyright © 2015. All Rights Reserved.