Vert.x 4.5.13 · io.vertx.core.impl.ContextImpl · APIdia, the JavaDoc alternative

Modifier and Type	Field and Description
private final CloseFuture	closeFuture
private final JsonObject	config References Deprecated `JsonObject` is deprecated or references (maybe indirectly) at least one deprecated element.
private ConcurrentMap<Object, Object>	data
private final Deployment	deployment
pack-priv static final boolean	DISABLE_TIMINGS
private static final String	DISABLE_TIMINGS_PROP_NAME
private final EventLoop	eventLoop
private volatile Handler<Throwable>	exceptionHandler
pack-priv final WorkerTaskQueue	executeBlockingTasks
private final EventExecutor	executor
pack-priv final TaskQueue	internalOrderedTasks
pack-priv final WorkerPool	internalWorkerPool
private static final Logger	log
private final VertxImpl	owner
private final ClassLoader	tccl
private final ThreadingModel	threadingModel
pack-priv final WorkerPool	workerPool

Access	Constructor and Description
public	ContextImpl(VertxImpl vertx, int localsLength, ThreadingModel threadingModel, EventLoop eventLoop, EventExecutor executor, WorkerPool internalWorkerPool, WorkerPool workerPool, Deployment deployment, CloseFuture closeFuture, ClassLoader tccl)

Method Summary

Modifier and Type	Method and Description
public ClassLoader	classLoader() Implements io.vertx.core.impl.ContextInternal.classLoader.
public Future<Void>	close() Implements io.vertx.core.impl.ContextInternal.close. Close this context, cleanup close future hooks then dispose pending ordered task queue.
public CloseFuture	closeFuture() Implements io.vertx.core.impl.ContextInternal.closeFuture.
public JsonObject	config() Implements io.vertx.core.Context.config. References Deprecated `JsonObject` is deprecated or references (maybe indirectly) at least one deprecated element. If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.
public synchronized ConcurrentMap<Object, Object>	contextData() Implements io.vertx.core.impl.ContextInternal.contextData.
public ContextInternal	duplicate() Implements io.vertx.core.impl.ContextInternal.duplicate. Returns a context sharing with this context the same concurrency the same exception handler the same context data the same deployment the same config the same classloader
public <T> void	emit(T the `task` argument argument, Handler<T> the handler to execute with the `event` argument task) Implements io.vertx.core.impl.ContextInternal.emit. Emit the given `argument` event to the `task` and switch on this context if necessary, this also associates the current thread with the current context so `Vertx#currentContext()` returns this context.
protected <T> void	emit(ContextInternal ctx, T argument, Handler<T> task)
public Context	exceptionHandler(Handler<Throwable> handler)
public Handler<Throwable>	exceptionHandler() Implements io.vertx.core.Context.exceptionHandler.
public void	execute(Runnable the task to execute task) Implements io.vertx.core.impl.ContextInternal.execute. Execute the `task` on this context, it will be executed according to the context concurrency model.
public final <T> void	execute(T the `task` argument argument, Handler<T> the task to execute task) Implements io.vertx.core.impl.ContextInternal.execute. Execute a `task` on this context, the task will be executed according to the context concurrency model.
protected void	execute(ContextInternal ctx, Runnable task)
protected <T> void	execute(ContextInternal ctx, T argument, Handler<T> task) When the current thread is event-loop thread of this context the implementation will execute the `task` directly When the current thread is a worker thread of this context the implementation will execute the `task` directly Otherwise the task will be scheduled on the context thread for execution
public <T> Future<T>	executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered) Implements io.vertx.core.Context.executeBlocking. Same as `executeBlocking(Handler, boolean, Handler)` but with an `handler` called when the operation completes
public <T> Future<T>	executeBlocking(Callable<T> handler representing the blocking code to run blockingCodeHandler, boolean 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 ordered) Implements io.vertx.core.Context.executeBlocking. Safely execute some blocking code.
public <T> Future<T>	executeBlocking(Handler<Promise<T>> blockingCodeHandler, TaskQueue queue) Implements io.vertx.core.impl.ContextInternal.executeBlocking. Like `executeBlocking(Handler, boolean)` but uses the `queue` to order the tasks instead of the internal queue of this context.
public <T> Future<T>	executeBlocking(Callable<T> blockingCodeHandler, TaskQueue queue) Implements io.vertx.core.impl.ContextInternal.executeBlocking.
pack-priv static <T> Future<T>	executeBlocking(ContextInternal context, Callable<T> blockingCodeHandler, WorkerPool workerPool, TaskQueue queue)
pack-priv static <T> Future<T>	executeBlocking(ContextInternal context, Handler<Promise<T>> blockingCodeHandler, WorkerPool workerPool, TaskQueue queue)
public <T> Future<T>	executeBlockingInternal(Handler<Promise<T>> action) Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal. Like `executeBlockingInternal(Handler, Handler)` but returns a `Future` of the asynchronous result
public <T> Future<T>	executeBlockingInternal(Callable<T> action) Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal.
public <T> Future<T>	executeBlockingInternal(Handler<Promise<T>> action, boolean ordered) Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal. Like `executeBlockingInternal(Handler, boolean, Handler)` but returns a `Future` of the asynchronous result
public <T> Future<T>	executeBlockingInternal(Callable<T> action, boolean ordered) Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal.
public EventExecutor	executor() Implements io.vertx.core.impl.ContextInternal.executor.
public Deployment	getDeployment() Implements io.vertx.core.impl.ContextInternal.getDeployment.
private static <T> Future<T>	internalExecuteBlocking(ContextInternal context, Handler<Promise<T>> blockingCodeHandler, WorkerPool workerPool, TaskQueue queue)
public boolean	inThread() Implements io.vertx.core.impl.ContextInternal.inThread.
public boolean	isEventLoopContext() Implements io.vertx.core.Context.isEventLoopContext. Is the current context an event loop context?
public boolean	isWorkerContext() Implements io.vertx.core.Context.isWorkerContext. Is the current context a worker context?
public EventLoop	nettyEventLoop() Implements io.vertx.core.impl.ContextInternal.nettyEventLoop. Return the Netty EventLoop used by this Context.
public VertxImpl	owner() Implements io.vertx.core.impl.ContextInternal.owner.
public void	reportException(Throwable the exception to report t) Implements io.vertx.core.impl.ContextInternal.reportException. Report an exception to this context synchronously.
protected void	runOnContext(ContextInternal ctx, Handler<Void> action)
pack-priv static <T> void	setResultHandler(ContextInternal ctx, Future<T> fut, Handler<AsyncResult<T>> resultHandler)
public ThreadingModel	threadingModel() Implements io.vertx.core.Context.threadingModel.
public VertxTracer<I, O>	tracer() Implements io.vertx.core.impl.ContextInternal.tracer.
public WorkerPool	workerPool() Implements io.vertx.core.impl.ContextInternal.workerPool.

Inherited from io.vertx.core.impl.ContextBase:: getLocal getLocal putLocal

closeFuture	back to summary
private final CloseFuture closeFuture

config	back to summary
private final JsonObject config References Deprecated `JsonObject` is deprecated or references (maybe indirectly) at least one deprecated element. See corresponding docs for further information.

data	back to summary
private ConcurrentMap<Object, Object> data

deployment	back to summary
private final Deployment deployment

DISABLE_TIMINGS	back to summary
pack-priv static final boolean DISABLE_TIMINGS

DISABLE_TIMINGS_PROP_NAME	back to summary
private static final String DISABLE_TIMINGS_PROP_NAME

eventLoop	back to summary
private final EventLoop eventLoop

exceptionHandler	back to summary
private volatile Handler<Throwable> exceptionHandler

executeBlockingTasks	back to summary
pack-priv final WorkerTaskQueue executeBlockingTasks

executor	back to summary
private final EventExecutor executor

internalOrderedTasks	back to summary
pack-priv final TaskQueue internalOrderedTasks

internalWorkerPool	back to summary
pack-priv final WorkerPool internalWorkerPool

log	back to summary
private static final Logger log

owner	back to summary
private final VertxImpl owner

tccl	back to summary
private final ClassLoader tccl

threadingModel	back to summary
private final ThreadingModel threadingModel

workerPool	back to summary
pack-priv final WorkerPool workerPool

ContextImpl	back to summary
public ContextImpl(VertxImpl vertx, int localsLength, ThreadingModel threadingModel, EventLoop eventLoop, EventExecutor executor, WorkerPool internalWorkerPool, WorkerPool workerPool, Deployment deployment, CloseFuture closeFuture, ClassLoader tccl)

Method Detail

classLoader	back to summary
public ClassLoader classLoader() Implements io.vertx.core.impl.ContextInternal.classLoader. Returns:ClassLoader Doc from io.vertx.core.impl.ContextInternal.classLoader. the classloader associated with this context Annotations @Override

classLoader

back to summary

public ClassLoader classLoader()

Implements io.vertx.core.impl.ContextInternal.classLoader.

Returns:ClassLoader

Doc from io.vertx.core.impl.ContextInternal.classLoader.

the classloader associated with this context

Annotations

@Override

close	back to summary
public Future<Void> close() Implements io.vertx.core.impl.ContextInternal.close. Doc from io.vertx.core.impl.ContextInternal.close. Close this context, cleanup close future hooks then dispose pending ordered task queue. Returns:Future<Void> a future signalling close completion

back to summary

public Future<Void> close()

Implements io.vertx.core.impl.ContextInternal.close.

Doc from io.vertx.core.impl.ContextInternal.close.

Close this context, cleanup close future hooks then dispose pending ordered task queue.

Returns:Future<Void>: a future signalling close completion

closeFuture	back to summary
public CloseFuture closeFuture() Implements io.vertx.core.impl.ContextInternal.closeFuture. Annotations @Override

closeFuture

back to summary

public CloseFuture closeFuture()

Implements io.vertx.core.impl.ContextInternal.closeFuture.

Annotations

@Override

config back to summary

config	back to summary
public JsonObject config() Implements io.vertx.core.Context.config. Doc from io.vertx.core.Context.config. References Deprecated `JsonObject` is deprecated or references (maybe indirectly) at least one deprecated element. See corresponding docs for further information. If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed. Returns:JsonObject the configuration of the deployment or null if not a Verticle deployment Annotations @Override

public JsonObject config()

Implements io.vertx.core.Context.config.

Doc from io.vertx.core.Context.config.

References Deprecated

JsonObject is deprecated or references (maybe indirectly) at least one deprecated element.

See corresponding docs for further information.

If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.

Returns:JsonObject

the configuration of the deployment or null if not a Verticle deployment

Annotations

@Override

contextData back to summary

contextData	back to summary
public synchronized ConcurrentMap<Object, Object> contextData() Implements io.vertx.core.impl.ContextInternal.contextData. Returns:ConcurrentMap<Object, Object> Doc from io.vertx.core.impl.ContextInternal.contextData. the `ConcurrentMap` used to store context data Annotations @Override

public synchronized ConcurrentMap<Object, Object> contextData()

Implements io.vertx.core.impl.ContextInternal.contextData.

Returns:ConcurrentMap<Object, Object>

Doc from io.vertx.core.impl.ContextInternal.contextData.

the ConcurrentMap used to store context data

Annotations

@Override

duplicate	back to summary
public ContextInternal duplicate() Implements io.vertx.core.impl.ContextInternal.duplicate. Doc from io.vertx.core.impl.ContextInternal.duplicate. Returns a context sharing with this context the same concurrency the same exception handler the same context data the same deployment the same config the same classloader The duplicate context has its own local context data worker task queue Returns:ContextInternal a duplicate of this context Annotations @Override

duplicate

back to summary

public ContextInternal duplicate()

Implements io.vertx.core.impl.ContextInternal.duplicate.

Doc from io.vertx.core.impl.ContextInternal.duplicate.

Returns a context sharing with this context

the same concurrency
the same exception handler
the same context data
the same deployment
the same config
the same classloader

The duplicate context has its own

local context data
worker task queue

Returns:ContextInternal

a duplicate of this context

Annotations

@Override

emit back to summary

emit	back to summary
public <T> void emit(T argument, Handler<T> task) Implements io.vertx.core.impl.ContextInternal.emit. Doc from io.vertx.core.impl.ContextInternal.emit. Emit the given `argument` event to the `task` and switch on this context if necessary, this also associates the current thread with the current context so `Vertx#currentContext()` returns this context. Any exception thrown from the task will be reported on this context. Calling this method is equivalent to `execute(v -> dispatch(argument, task))` Parameters argument:T the `task` argument task:Handler<T> the handler to execute with the `event` argument Annotations @Override

public <T> void emit(T argument, Handler<T> task)

Implements io.vertx.core.impl.ContextInternal.emit.

Doc from io.vertx.core.impl.ContextInternal.emit.

Emit the given argument event to the task and switch on this context if necessary, this also associates the current thread with the current context so Vertx#currentContext() returns this context.
Any exception thrown from the task will be reported on this context.
Calling this method is equivalent to execute(v -> dispatch(argument, task))

Parameters

argument:T: the task argument
task:Handler<T>: the handler to execute with the event argument

Annotations

@Override

emit	back to summary
protected <T> void emit(ContextInternal ctx, T argument, Handler<T> task)

exceptionHandler	back to summary
public Context exceptionHandler(Handler<Throwable> handler) Annotations @Override

exceptionHandler	back to summary
public Handler<Throwable> exceptionHandler() Implements io.vertx.core.Context.exceptionHandler. Returns:Handler<Throwable> Doc from io.vertx.core.Context.exceptionHandler. the current exception handler of this context Annotations @Override

exceptionHandler

back to summary

public Handler<Throwable> exceptionHandler()

Implements io.vertx.core.Context.exceptionHandler.

Returns:Handler<Throwable>

Doc from io.vertx.core.Context.exceptionHandler.

the current exception handler of this context

Annotations

@Override

execute back to summary

execute	back to summary
public void execute(Runnable task) Implements io.vertx.core.impl.ContextInternal.execute. Doc from io.vertx.core.impl.ContextInternal.execute. Execute the `task` on this context, it will be executed according to the context concurrency model. Parameters task:Runnable the task to execute Annotations @Override

public void execute(Runnable task)

Implements io.vertx.core.impl.ContextInternal.execute.

Doc from io.vertx.core.impl.ContextInternal.execute.

Execute the task on this context, it will be executed according to the context concurrency model.

Parameters

task:Runnable: the task to execute

Annotations

@Override

execute back to summary

execute	back to summary
public final <T> void execute(T argument, Handler<T> task) Implements io.vertx.core.impl.ContextInternal.execute. Doc from io.vertx.core.impl.ContextInternal.execute. Execute a `task` on this context, the task will be executed according to the context concurrency model. Parameters argument:T the `task` argument task:Handler<T> the task to execute Annotations @Override

public final <T> void execute(T argument, Handler<T> task)

Implements io.vertx.core.impl.ContextInternal.execute.

Doc from io.vertx.core.impl.ContextInternal.execute.

Execute a task on this context, the task will be executed according to the context concurrency model.

Parameters

argument:T: the task argument
task:Handler<T>: the task to execute

Annotations

@Override

execute	back to summary
protected void execute(ContextInternal ctx, Runnable task)

execute back to summary

execute	back to summary
protected <T> void execute(ContextInternal ctx, T argument, Handler<T> task) When the current thread is event-loop thread of this context the implementation will execute the `task` directly When the current thread is a worker thread of this context the implementation will execute the `task` directly Otherwise the task will be scheduled on the context thread for execution

protected <T> void execute(ContextInternal ctx, T argument, Handler<T> task)

When the current thread is event-loop thread of this context the implementation will execute the task directly
When the current thread is a worker thread of this context the implementation will execute the task directly
Otherwise the task will be scheduled on the context thread for execution

executeBlocking back to summary

executeBlocking	back to summary
public <T> Future<T> executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered) Implements io.vertx.core.Context.executeBlocking. Doc from io.vertx.core.Context.executeBlocking. Same as `executeBlocking(Handler, boolean, Handler)` but with an `handler` called when the operation completes Annotations @Override

public <T> Future<T> executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)

Implements io.vertx.core.Context.executeBlocking.

Doc from io.vertx.core.Context.executeBlocking.

Same as executeBlocking(Handler, boolean, Handler) but with an handler called when the operation completes

Annotations

@Override

executeBlocking back to summary

executeBlocking	back to summary
public <T> Future<T> executeBlocking(Callable<T> blockingCodeHandler, boolean ordered) Implements io.vertx.core.Context.executeBlocking. Doc from io.vertx.core.Context.executeBlocking. 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 `Context#runOnContext(Handler)` Parameters <T> the type of the result blockingCodeHandler:Callable<T> handler representing the blocking code to run ordered:boolean 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:Future<T> a future completed when the blocking code is complete Annotations @Override

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

Implements io.vertx.core.Context.executeBlocking.

Doc from io.vertx.core.Context.executeBlocking.

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 Context#runOnContext(Handler)

Parameters

<T>: the type of the result
blockingCodeHandler:Callable<T>: handler representing the blocking code to run
ordered:boolean: 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:Future<T>

a future completed when the blocking code is complete

Annotations

@Override

executeBlocking back to summary

executeBlocking	back to summary
public <T> Future<T> executeBlocking(Handler<Promise<T>> blockingCodeHandler, TaskQueue queue) Implements io.vertx.core.impl.ContextInternal.executeBlocking. Doc from io.vertx.core.impl.ContextInternal.executeBlocking. Like `executeBlocking(Handler, boolean)` but uses the `queue` to order the tasks instead of the internal queue of this context. Annotations @Override

public <T> Future<T> executeBlocking(Handler<Promise<T>> blockingCodeHandler, TaskQueue queue)

Implements io.vertx.core.impl.ContextInternal.executeBlocking.

Doc from io.vertx.core.impl.ContextInternal.executeBlocking.

Like executeBlocking(Handler, boolean) but uses the queue to order the tasks instead of the internal queue of this context.

Annotations

@Override

executeBlocking	back to summary
public <T> Future<T> executeBlocking(Callable<T> blockingCodeHandler, TaskQueue queue) Implements io.vertx.core.impl.ContextInternal.executeBlocking. Annotations @Override

executeBlocking

back to summary

public <T> Future<T> executeBlocking(Callable<T> blockingCodeHandler, TaskQueue queue)

Implements io.vertx.core.impl.ContextInternal.executeBlocking.

Annotations

@Override

executeBlocking	back to summary
pack-priv static <T> Future<T> executeBlocking(ContextInternal context, Callable<T> blockingCodeHandler, WorkerPool workerPool, TaskQueue queue)

executeBlocking	back to summary
pack-priv static <T> Future<T> executeBlocking(ContextInternal context, Handler<Promise<T>> blockingCodeHandler, WorkerPool workerPool, TaskQueue queue)

executeBlockingInternal back to summary

executeBlockingInternal	back to summary
public <T> Future<T> executeBlockingInternal(Handler<Promise<T>> action) Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal. Doc from io.vertx.core.impl.ContextInternal.executeBlockingInternal. Like `executeBlockingInternal(Handler, Handler)` but returns a `Future` of the asynchronous result Annotations @Override

public <T> Future<T> executeBlockingInternal(Handler<Promise<T>> action)

Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal.

Doc from io.vertx.core.impl.ContextInternal.executeBlockingInternal.

Like executeBlockingInternal(Handler, Handler) but returns a Future of the asynchronous result

Annotations

@Override

executeBlockingInternal	back to summary
public <T> Future<T> executeBlockingInternal(Callable<T> action) Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal. Annotations @Override

executeBlockingInternal

back to summary

public <T> Future<T> executeBlockingInternal(Callable<T> action)

Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal.

Annotations

@Override

executeBlockingInternal back to summary

executeBlockingInternal	back to summary
public <T> Future<T> executeBlockingInternal(Handler<Promise<T>> action, boolean ordered) Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal. Doc from io.vertx.core.impl.ContextInternal.executeBlockingInternal. Like `executeBlockingInternal(Handler, boolean, Handler)` but returns a `Future` of the asynchronous result Annotations @Override

public <T> Future<T> executeBlockingInternal(Handler<Promise<T>> action, boolean ordered)

Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal.

Doc from io.vertx.core.impl.ContextInternal.executeBlockingInternal.

Like executeBlockingInternal(Handler, boolean, Handler) but returns a Future of the asynchronous result

Annotations

@Override

executeBlockingInternal	back to summary
public <T> Future<T> executeBlockingInternal(Callable<T> action, boolean ordered) Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal. Annotations @Override

executeBlockingInternal

back to summary

public <T> Future<T> executeBlockingInternal(Callable<T> action, boolean ordered)

Implements io.vertx.core.impl.ContextInternal.executeBlockingInternal.

Annotations

@Override

executor	back to summary
public EventExecutor executor() Implements io.vertx.core.impl.ContextInternal.executor. Returns:EventExecutor Doc from io.vertx.core.impl.ContextInternal.executor. an executor that schedule a task on this context, the thread executing the task will not be associated with this context Annotations @Override

executor

back to summary

public EventExecutor executor()

Implements io.vertx.core.impl.ContextInternal.executor.

Returns:EventExecutor

Doc from io.vertx.core.impl.ContextInternal.executor.

an executor that schedule a task on this context, the thread executing the task will not be associated with this context

Annotations

@Override

getDeployment back to summary

getDeployment	back to summary
public Deployment getDeployment() Implements io.vertx.core.impl.ContextInternal.getDeployment. Returns:Deployment Doc from io.vertx.core.impl.ContextInternal.getDeployment. the deployment associated with this context or `null`

public Deployment getDeployment()

Implements io.vertx.core.impl.ContextInternal.getDeployment.

Returns:Deployment

Doc from io.vertx.core.impl.ContextInternal.getDeployment.

the deployment associated with this context or null

internalExecuteBlocking	back to summary
private static <T> Future<T> internalExecuteBlocking(ContextInternal context, Handler<Promise<T>> blockingCodeHandler, WorkerPool workerPool, TaskQueue queue)

inThread	back to summary
public boolean inThread() Implements io.vertx.core.impl.ContextInternal.inThread. Annotations @Override

inThread

back to summary

public boolean inThread()

Implements io.vertx.core.impl.ContextInternal.inThread.

Annotations

@Override

isEventLoopContext back to summary

isEventLoopContext	back to summary
public boolean isEventLoopContext() Implements io.vertx.core.Context.isEventLoopContext. Doc from io.vertx.core.Context.isEventLoopContext. Is the current context an event loop context? Note when running blocking code using `io.vertx.core.Vertx#executeBlocking(Callable)` from a standard (not worker) verticle, the context will still an event loop context and this `this#isEventLoopContext()` will return true. Returns:boolean true if false otherwise Annotations @Override

public boolean isEventLoopContext()

Implements io.vertx.core.Context.isEventLoopContext.

Doc from io.vertx.core.Context.isEventLoopContext.

Is the current context an event loop context?

Note

when running blocking code using io.vertx.core.Vertx#executeBlocking(Callable) from a standard (not worker) verticle, the context will still an event loop context and this this#isEventLoopContext() will return true.

Returns:boolean

true if false otherwise

Annotations