vertx / io.vertx.reactivex.core / Context

# Context

`open class Context`

The execution context of a io.vertx.reactivex.core.Handler execution.

When Vert.x provides an event to a handler or calls the start or stop methods of a io.vertx.reactivex.core.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 `io.vertx.reactivex.core.Context#put` and `io.vertx.reactivex.core.Context#get` on the context so it can be shared easily amongst different handlers of, for example, a verticle instance.

This class also provides `io.vertx.reactivex.core.Context#runOnContext` which allows an action to be executed asynchronously using the same context.

NOTE: This class has been automatically generated from the io.vertx.core.Context non RX-ified interface using Vert.x codegen.

### Constructors

<init> | `Context(delegate: Context)`

### Properties

__TYPE_ARG | `static val __TYPE_ARG: TypeArg<Context>`

### Functions

config | `open fun config(): JsonObject` If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.
deploymentID | `open fun deploymentID(): String` If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.
equals | `open fun equals(other: Any?): Boolean`
exceptionHandler | `open fun exceptionHandler(handler: Handler<Throwable>): Context` Set an exception handler called when the context runs an action throwing an uncaught throwable. When this handler is called, `io.vertx.reactivex.core.Vertx#currentContext` will return this context.
executeBlocking | `open fun <T : Any> executeBlocking(blockingCodeHandler: Handler<Future<T>>, ordered: Boolean, resultHandler: Handler<AsyncResult<T>>): Unit` 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 `io.vertx.reactivex.core.Future#complete` or `io.vertx.reactivex.core.Future#complete` method, or the `io.vertx.reactivex.core.Future#fail` method if it failed. `open fun <T : Any> executeBlocking(blockingCodeHandler: Handler<Future<T>>, resultHandler: Handler<AsyncResult<T>>): Unit` Invoke `io.vertx.reactivex.core.Context#executeBlocking` with order = true.
get | `open fun <T : Any> get(key: String): T` Get some data from the context.
getDelegate | `open fun getDelegate(): Context`
getInstanceCount | `open fun getInstanceCount(): Int`
hashCode | `open fun hashCode(): Int`
isEventLoopContext | `open fun isEventLoopContext(): Boolean` Is the current context an event loop context? NOTE! when running blocking code using `io.vertx.reactivex.core.Vertx#executeBlocking` from a standard (not worker) verticle, the context will still an event loop context and this will return true.
isMultiThreadedWorkerContext | `open fun isMultiThreadedWorkerContext(): Boolean` Is the current context a multi-threaded worker context?
isOnEventLoopThread | `open static fun isOnEventLoopThread(): Boolean` Is the current thread an event thread? NOTE! This is not always the same as calling `io.vertx.reactivex.core.Context#isEventLoopContext`. If you are running blocking code from an event loop context, then this will return false but `io.vertx.reactivex.core.Context#isEventLoopContext` will return true.
isOnVertxThread | `open static fun isOnVertxThread(): Boolean` Is the current thread a Vert.x thread? That's either a worker thread or an event loop thread
isOnWorkerThread | `open static fun isOnWorkerThread(): Boolean` Is the current thread a worker thread? NOTE! This is not always the same as calling `io.vertx.reactivex.core.Context#isWorkerContext`. If you are running blocking code from an event loop context, then this will return true but `io.vertx.reactivex.core.Context#isWorkerContext` will return false.
isWorkerContext | `open fun isWorkerContext(): Boolean` Is the current context a worker context? NOTE! when running blocking code using `io.vertx.reactivex.core.Vertx#executeBlocking` from a standard (not worker) verticle, the context will still an event loop context and this will return false.
newInstance | `open static fun newInstance(arg: Context): Context`
owner | `open fun owner(): Vertx`
processArgs | `open fun processArgs(): MutableList<String>` The process args
put | `open fun put(key: String, value: Any): Unit` Put some data in the context. This can be used to share data between different handlers that share a context
remove | `open fun remove(key: String): Boolean` Remove some data from the context.
runOnContext | `open fun runOnContext(action: Handler<Void>): Unit` Run the specified action asynchronously on the same context, some time after the current execution has completed.
rxExecuteBlocking | `open fun <T : Any> rxExecuteBlocking(blockingCodeHandler: Handler<Future<T>>, ordered: Boolean): Single<T>` 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 `io.vertx.reactivex.core.Future#complete` or `io.vertx.reactivex.core.Future#complete` method, or the `io.vertx.reactivex.core.Future#fail` method if it failed. `open fun <T : Any> rxExecuteBlocking(blockingCodeHandler: Handler<Future<T>>): Single<T>` Invoke `io.vertx.reactivex.core.Context#executeBlocking` with order = true.
toString | `open fun toString(): String`