ContextImpl (Vert.x Core 3.0.0 API)

java.lang.Object
- io.vertx.core.impl.ContextImpl

All Implemented Interfaces:

Context

Direct Known Subclasses:

EventLoopContext, WorkerContext
```
public abstract class ContextImpl
extends Object
implements Context
```
Author:

Tim Fox

Field Summary

Fields
Modifier and Type	Field and Description
`protected JsonObject`	`config`
`protected io.vertx.core.impl.VertxThread`	`contextThread`
`protected String`	`deploymentID`
`protected Executor`	`orderedInternalPoolExec`
`protected VertxInternal`	`owner`
`protected Executor`	`workerExec`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`ContextImpl(VertxInternal vertx, Executor orderedInternalPoolExec, Executor workerExec, String deploymentID, JsonObject config, ClassLoader tccl)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addCloseHook(Closeable hook)`
`protected abstract void`	`checkCorrectThread()`
`JsonObject`	`config()` If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.
`protected Map<String,Object>`	`contextData()`
`String`	`deploymentID()` If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.
`io.netty.channel.EventLoop`	`eventLoop()`
`protected abstract void`	`executeAsync(Handler<Void> task)`
`<T> void`	`executeBlocking(Action<T> action, Handler<AsyncResult<T>> resultHandler)`
`<T> void`	`executeBlocking(Handler<Future<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)`
`void`	`executeFromIO(ContextTask task)`
`<T> T`	`get(String key)` Get some data from the context.
`Deployment`	`getDeployment()`
`int`	`getInstanceCount()`
`abstract boolean`	`isEventLoopContext()` Is the current context an event loop context?
`abstract 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?
`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`	`removeCloseHook(Closeable hook)`
`void`	`runCloseHooks(Handler<AsyncResult<Void>> completionHandler)`
`void`	`runOnContext(Handler<Void> task)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
`static void`	`setContext(ContextImpl context)`
`void`	`setDeployment(Deployment deployment)`
`protected Runnable`	`wrapTask(ContextTask cTask, Handler<Void> hTask, boolean checkThread)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - owner
```
protected final VertxInternal owner
```
  - deploymentID
```
protected final String deploymentID
```
  - config
```
protected final JsonObject config
```
  - orderedInternalPoolExec
```
protected final Executor orderedInternalPoolExec
```
  - workerExec
```
protected final Executor workerExec
```
  - contextThread
```
protected io.vertx.core.impl.VertxThread contextThread
```
- Constructor Detail
  - ContextImpl
```
protected ContextImpl(VertxInternal vertx,
                      Executor orderedInternalPoolExec,
                      Executor workerExec,
                      String deploymentID,
                      JsonObject config,
                      ClassLoader tccl)
```
- Method Detail
  - setContext
```
public static void setContext(ContextImpl context)
```
  - setDeployment
```
public void setDeployment(Deployment deployment)
```
  - getDeployment
```
public Deployment getDeployment()
```
  - addCloseHook
```
public void addCloseHook(Closeable hook)
```
  - removeCloseHook
```
public void removeCloseHook(Closeable hook)
```
  - runCloseHooks
```
public void runCloseHooks(Handler<AsyncResult<Void>> completionHandler)
```
  - executeAsync
```
protected abstract void executeAsync(Handler<Void> task)
```
  - isEventLoopContext
```
public abstract boolean isEventLoopContext()
```
    Description copied from interface: Context
    
    Is the current context an event loop context?
    NOTE! when running blocking code using Vertx.executeBlocking(Handler, Handler) from a standard (not worker) verticle, the context will still an event loop context and this this#isEventLoopContext() will return true.
    
    Specified by:
    
    isEventLoopContext in interface Context
    
    Returns:
    
    true if false otherwise
  - isMultiThreadedWorkerContext
```
public abstract boolean isMultiThreadedWorkerContext()
```
    Description copied from interface: Context
    
    Is the current context a multi-threaded worker context?
    
    Specified by:
    
    isMultiThreadedWorkerContext in interface Context
    
    Returns:
    
    true if the current context is a multi-threaded worker context, false otherwise
  - get
```
public <T> T get(String key)
```
    Description copied from interface: Context
    
    Get some data from the context.
    
    Specified by:
    
    get in interface Context
    
    Type Parameters:
    
    T - the type of the data
    
    Parameters:
    
    key - the key of the data
    
    Returns:
    
    the data
  - put
```
public void put(String key,
                Object value)
```
    Description copied from interface: Context
    
    Put some data in the context.
    This can be used to share data between different handlers that share a context
    
    Specified by:
    
    put in interface Context
    
    Parameters:
    
    key - the key of the data
    
    value - the data
  - remove
```
public boolean remove(String key)
```
    Description copied from interface: Context
    
    Remove some data from the context.
    
    Specified by:
    
    remove in interface Context
    
    Parameters:
    
    key - the key to remove
    
    Returns:
    
    true if removed successfully, false otherwise
  - isWorkerContext
```
public boolean isWorkerContext()
```
    Description copied from interface: Context
    
    Is the current context a worker context?
    NOTE! when running blocking code using Vertx.executeBlocking(Handler, Handler) from a standard (not worker) verticle, the context will still an event loop context and this this#isWorkerContext() will return false.
    
    Specified by:
    
    isWorkerContext in interface Context
    
    Returns:
    
    true if the current context is a worker context, false otherwise
  - isOnWorkerThread
```
public static boolean isOnWorkerThread()
```
    Description copied from interface: Context
    
    Is the current thread a worker thread?
    NOTE! This is not always the same as calling Context.isWorkerContext(). If you are running blocking code from an event loop context, then this will return true but Context.isWorkerContext() will return false.
    
    Specified by:
    
    isOnWorkerThread in interface Context
    
    Returns:
    
    true if current thread is a worker thread, false otherwise
  - isOnEventLoopThread
```
public static boolean isOnEventLoopThread()
```
    Description copied from interface: Context
    
    Is the current thread an event thread?
    NOTE! This is not always the same as calling Context.isEventLoopContext(). If you are running blocking code from an event loop context, then this will return false but Context.isEventLoopContext() will return true.
    
    Specified by:
    
    isOnEventLoopThread in interface Context
    
    Returns:
    
    true if current thread is a worker thread, false otherwise
  - isOnVertxThread
```
public static boolean isOnVertxThread()
```
    Description copied from interface: Context
    
    Is the current thread a Vert.x thread? That's either a worker thread or an event loop thread
    
    Specified by:
    
    isOnVertxThread in interface Context
    
    Returns:
    
    true if current thread is a Vert.x thread, false otherwise
  - executeFromIO
```
public void executeFromIO(ContextTask task)
```
  - checkCorrectThread
```
protected abstract void checkCorrectThread()
```
  - runOnContext
```
public void runOnContext(Handler<Void> task)
```
    Description copied from interface: Context
    
    Run the specified action asynchronously on the same context, some time after the current execution has completed.
    
    Specified by:
    
    runOnContext in interface Context
    
    Parameters:
    
    task - the action to run
  - deploymentID
```
public String deploymentID()
```
    Description copied from interface: Context
    
    If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.
    
    Specified by:
    
    deploymentID in interface Context
    
    Returns:
    
    the deployment ID of the deployment or null if not a Verticle deployment
  - config
```
public JsonObject config()
```
    Description copied from interface: Context
    
    If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.
    
    Specified by:
    
    config in interface Context
    
    Returns:
    
    the configuration of the deployment or null if not a Verticle deployment
  - processArgs
```
public List<String> processArgs()
```
    Description copied from interface: Context
    
    The process args
    
    Specified by:
    
    processArgs in interface Context
  - eventLoop
```
public io.netty.channel.EventLoop eventLoop()
```
  - owner
```
public Vertx owner()
```
    Specified by:
    
    owner in interface Context
    
    Returns:
    
    The Vertx instance that created the context
  - executeBlocking
```
public <T> void executeBlocking(Action<T> action,
                                Handler<AsyncResult<T>> resultHandler)
```
  - executeBlocking
```
public <T> void executeBlocking(Handler<Future<T>> blockingCodeHandler,
                                boolean ordered,
                                Handler<AsyncResult<T>> resultHandler)
```
  - contextData
```
protected Map<String,Object> contextData()
```
  - wrapTask
```
protected Runnable wrapTask(ContextTask cTask,
                            Handler<Void> hTask,
                            boolean checkThread)
```
  - getInstanceCount
```
public int getInstanceCount()
```
    Specified by:
    
    getInstanceCount in interface Context
    
    Returns:
    
    the number of instances of the verticle that were deployed in the deployment (if any) related to this context

Class ContextImpl

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

owner

deploymentID

config

orderedInternalPoolExec

workerExec

contextThread

Constructor Detail

ContextImpl

Method Detail

setContext

setDeployment

getDeployment

addCloseHook

removeCloseHook

runCloseHooks

executeAsync

isEventLoopContext

isMultiThreadedWorkerContext

get

put

remove

isWorkerContext

isOnWorkerThread

isOnEventLoopThread

isOnVertxThread

executeFromIO

checkCorrectThread

runOnContext

deploymentID

config

processArgs

eventLoop

owner

executeBlocking

executeBlocking

contextData

wrapTask

getInstanceCount