Package io.vertx.reactivex.core

## Class Context

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

- All Implemented Interfaces:
    `io.vertx.lang.rx.RxDelegate`

      public class Context
      extends Object
      implements io.vertx.lang.rx.RxDelegate

  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 multithreaded 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.Object, java.lang.Object)` and `get(java.lang.Object)` 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.

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static io.vertx.lang.rx.TypeArg<Context>` | `__TYPE_ARG` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `Context​(Context delegate)` |
    `Context​(Object delegate)` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method | 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.
    `boolean` | `equals​(Object o)` |
    `Context` | `exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler called when the context runs an action throwing an uncaught throwable.
    `<T> Future<T>` | `executeBlocking​(Callable<T> blockingCodeHandler)` | Invoke `executeBlocking(java.util.concurrent.Callable<T>, boolean)` with order = true.
    `<T> Future<T>` | `executeBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `<T> T` | `get​(Object key)` | Get some data from the context.
    `Context` | `getDelegate()` |
    `int` | `getInstanceCount()` |
    `<T> T` | `getLocal​(ContextLocal<T> key)` | Get local data associated with `key` using the concurrent access mode.
    `<T> T` | `getLocal​(ContextLocal<T> key, AccessMode accessMode)` | Get local data associated with `key` using the specified access mode.
    `int` | `hashCode()` |
    `boolean` | `isEventLoopContext()` | Is the current context an event loop context?
    `static boolean` | `isOnEventLoopThread()` | Is the current thread an event thread?
    `static boolean` | `isOnVertxThread()` | Is the current thread a Vert.x 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()` | Deprecated.
    `void` | `put​(Object key, Object value)` | Put some data in the context.
    `<T> void` | `putLocal​(ContextLocal<T> key, AccessMode accessMode, T value)` | Associate local data with `key` using the specified access mode.
    `<T> void` | `putLocal​(ContextLocal<T> key, T value)` | Associate local data with `key` using the concurrent access mode.
    `boolean` | `remove​(Object key)` | Remove some data from the context.
    `<T> void` | `removeLocal​(ContextLocal<T> key)` | Remove local data associated with `key` using the concurrent access mode.
    `<T> void` | `removeLocal​(ContextLocal<T> key, AccessMode accessMode)` | Remove local data associated with `key` using the specified access mode.
    `void` | `runOnContext​(Handler<Void> action)` | Run the specified action asynchronously on the same context, some time after the current execution has completed.
    `<T> Maybe<T>` | `rxExecuteBlocking​(Callable<T> blockingCodeHandler)` | Invoke `executeBlocking(java.util.concurrent.Callable<T>, boolean)` with order = true.
    `<T> Maybe<T>` | `rxExecuteBlocking​(Callable<T> blockingCodeHandler, boolean ordered)` | Safely execute some blocking code.
    `ThreadingModel` | `threadingModel()` |
    `String` | `toString()` |

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

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

- - ### Field Detail

    - #### __TYPE_ARG

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

  - ### Constructor Detail

    - #### Context

          public Context​(Context delegate)

    - #### Context

          public Context​(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 Context getDelegate()

      Specified by:
        `getDelegate` in interface `io.vertx.lang.rx.RxDelegate`

    - #### 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 `isEventLoopContext()`. If you are running blocking code from an event loop context, then this will return false but `isEventLoopContext()` will return true.

      Returns:
        true if current thread is an event 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

          @Deprecated
          public List<String> processArgs()

      Deprecated.
      Returns:
        an empty list

    - #### isEventLoopContext

          public boolean isEventLoopContext()

      Is the current context an event loop context?

      NOTE! when running blocking code using `Vertx.executeBlocking(java.util.concurrent.Callable<T>, boolean)` from a standard (not worker) verticle, the context will still an event loop context and this `isEventLoopContext()` will return true.

      Returns:
        `true` if the current context is an event-loop context, `false` otherwise

    - #### isWorkerContext

          public boolean isWorkerContext()

      Is the current context a worker context?

      NOTE! when running blocking code using `Vertx.executeBlocking(java.util.concurrent.Callable<T>, boolean)` 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

    - #### threadingModel

          public ThreadingModel threadingModel()

      Returns:
        the context threading model

    - #### get

          public <T> T get​(Object key)

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

    - #### put

          public void put​(Object 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​(Object 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

    - #### exceptionHandler

          public Context exceptionHandler​(Handler<Throwable> handler)

      Set an exception handler called when the context runs an action throwing an uncaught throwable.

      When this handler is called, `Vertx.currentContext()` will return this context.
      Parameters:
        `handler` - the exception handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### executeBlocking

          public <T> Future<T> executeBlocking​(Callable<T> blockingCodeHandler,
                                               boolean ordered)

      Safely execute some blocking code.

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

      The returned future will be completed with the result on the original context (i.e. on the original event loop of the caller) or failed when the handler throws an exception.

      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 `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:
        a future completed when the blocking code is complete

    - #### rxExecuteBlocking

          public <T> Maybe<T> rxExecuteBlocking​(Callable<T> blockingCodeHandler,
                                                boolean ordered)

      Safely execute some blocking code.

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

      The returned future will be completed with the result on the original context (i.e. on the original event loop of the caller) or failed when the handler throws an exception.

      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 `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:
        a future completed when the blocking code is complete

    - #### executeBlocking

          public <T> Future<T> executeBlocking​(Callable<T> blockingCodeHandler)

      Invoke `executeBlocking(java.util.concurrent.Callable<T>, boolean)` with order = true.
      Parameters:
        `blockingCodeHandler` - handler representing the blocking code to run
      Returns:
        a future completed when the blocking code is complete

    - #### rxExecuteBlocking

          public <T> Maybe<T> rxExecuteBlocking​(Callable<T> blockingCodeHandler)

      Invoke `executeBlocking(java.util.concurrent.Callable<T>, boolean)` with order = true.
      Parameters:
        `blockingCodeHandler` - handler representing the blocking code to run
      Returns:
        a future completed when the blocking code is complete

    - #### getLocal

          public <T> T getLocal​(ContextLocal<T> key)

      Get local data associated with `key` using the concurrent access mode.
      Parameters:
        `key` - the key of the data
      Returns:
        the local data

    - #### putLocal

          public <T> void putLocal​(ContextLocal<T> key,
                                   T value)

      Associate local data with `key` using the concurrent access mode.

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

    - #### removeLocal

          public <T> void removeLocal​(ContextLocal<T> key)

      Remove local data associated with `key` using the concurrent access mode.

      Parameters:
        `key` - the key to be removed

    - #### getLocal

          public <T> T getLocal​(ContextLocal<T> key,
                                AccessMode accessMode)

      Get local data associated with `key` using the specified access mode.

      Parameters:
        `key` - the key of the data
        `accessMode` - the access mode
      Returns:
        the local data

    - #### putLocal

          public <T> void putLocal​(ContextLocal<T> key,
                                   AccessMode accessMode,
                                   T value)

      Associate local data with `key` using the specified access mode.

      Parameters:
        `key` - the key of the data
        `accessMode` - the access mode
        `value` - the data

    - #### removeLocal

          public <T> void removeLocal​(ContextLocal<T> key,
                                      AccessMode accessMode)

      Remove local data associated with `key` using the specified access mode.

      Parameters:
        `key` - the key to be removed
        `accessMode` - the access mode

    - #### newInstance

          public static Context newInstance​(Context arg)