org.glassfish.jersey.process.internal.RequestScope.resumeCurrent java code examples

Common ways to obtain RequestScope

private void myMethod () {
 RequestScope r =ClientRuntime clientRuntime;clientRuntime.getRequestScope()
Smart code suggestions by Tabnine
}

/**
 * Runs the {@link Callable task} in the request scope initialized from the
 * {@link RequestScope.Instance scope instance}. The {@link RequestScope.Instance
 * scope instance} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestScope.Instance scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param scopeInstance The request scope instance from which the request scope will
 *                      be initialized.
 * @param task          Task to be executed.
 * @param <T>           {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(Instance scopeInstance, Callable<T> task) throws Exception {
  final Instance oldInstance = retrieveCurrent();
  try {
    setCurrent(scopeInstance.getReference());
    return Errors.process(task);
  } finally {
    scopeInstance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestScope.Instance scope instance}. The {@link RequestScope.Instance
 * scope instance} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestScope.Instance scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param scopeInstance The request scope instance from which the request scope will
 *                      be initialized.
 * @param task          Task to be executed.
 */
public void runInScope(Instance scopeInstance, Runnable task) {
  final Instance oldInstance = retrieveCurrent();
  try {
    setCurrent(scopeInstance.getReference());
    Errors.process(task);
  } finally {
    scopeInstance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestScope.Instance scope instance}. The {@link RequestScope.Instance
 * scope instance} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestScope.Instance scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param scopeInstance The request scope instance from which the request scope will
 *                      be initialized.
 * @param task          Task to be executed.
 */
public void runInScope(Instance scopeInstance, Runnable task) {
  final Instance oldInstance = retrieveCurrent();
  try {
    setCurrent(scopeInstance.getReference());
    Errors.process(task);
  } finally {
    scopeInstance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestScope.Instance scope instance}. The {@link RequestScope.Instance
 * scope instance} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestScope.Instance scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param scopeInstance The request scope instance from which the request scope will
 *                      be initialized.
 * @param task          Task to be executed.
 */
public void runInScope(Instance scopeInstance, Runnable task) {
  final Instance oldInstance = retrieveCurrent();
  try {
    setCurrent(scopeInstance.getReference());
    Errors.process(task);
  } finally {
    scopeInstance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Callable task} in the request scope initialized from the
 * {@link RequestScope.Instance scope instance}. The {@link RequestScope.Instance
 * scope instance} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestScope.Instance scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param scopeInstance The request scope instance from which the request scope will
 *                      be initialized.
 * @param task          Task to be executed.
 * @param <T>           {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(Instance scopeInstance, Callable<T> task) throws Exception {
  final Instance oldInstance = retrieveCurrent();
  try {
    setCurrent(scopeInstance.getReference());
    return Errors.process(task);
  } finally {
    scopeInstance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the request scope initialized
 * from the {@link RequestScope.Instance scope instance}.
 * The {@link RequestScope.Instance scope instance} is NOT released by the method (this
 * must be done explicitly). The current thread might be already in any request scope
 * and in that case the scope will be changed to the scope defined by the
 * {@link RequestScope.Instance scope instance}. At the end of the method the request
 * scope is returned to its original state.
 *
 * @param scopeInstance The request scope instance from which the request scope will
 *                      be initialized.
 * @param task          Task to be executed.
 * @param <T>           {@code task} result type.
 * @return result returned by the {@code task}
 */
public <T> T runInScope(Instance scopeInstance, Producer<T> task) {
  final Instance oldInstance = retrieveCurrent();
  try {
    setCurrent(scopeInstance.getReference());
    return Errors.process(task);
  } finally {
    scopeInstance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Callable task} in the request scope initialized from the
 * {@link RequestScope.Instance scope instance}. The {@link RequestScope.Instance
 * scope instance} is NOT released by the method (this must be done explicitly). The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestScope.Instance scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param scopeInstance The request scope instance from which the request scope will
 *                      be initialized.
 * @param task          Task to be executed.
 * @param <T>           {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(Instance scopeInstance, Callable<T> task) throws Exception {
  final Instance oldInstance = retrieveCurrent();
  try {
    setCurrent(scopeInstance.getReference());
    return Errors.process(task);
  } finally {
    scopeInstance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the request scope initialized
 * from the {@link RequestScope.Instance scope instance}.
 * The {@link RequestScope.Instance scope instance} is NOT released by the method (this
 * must be done explicitly). The current thread might be already in any request scope
 * and in that case the scope will be changed to the scope defined by the
 * {@link RequestScope.Instance scope instance}. At the end of the method the request
 * scope is returned to its original state.
 *
 * @param scopeInstance The request scope instance from which the request scope will
 *                      be initialized.
 * @param task          Task to be executed.
 * @param <T>           {@code task} result type.
 * @return result returned by the {@code task}
 */
public <T> T runInScope(Instance scopeInstance, Producer<T> task) {
  final Instance oldInstance = retrieveCurrent();
  try {
    setCurrent(scopeInstance.getReference());
    return Errors.process(task);
  } finally {
    scopeInstance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the request scope initialized
 * from the {@link RequestScope.Instance scope instance}.
 * The {@link RequestScope.Instance scope instance} is NOT released by the method (this
 * must be done explicitly). The current thread might be already in any request scope
 * and in that case the scope will be changed to the scope defined by the
 * {@link RequestScope.Instance scope instance}. At the end of the method the request
 * scope is returned to its original state.
 *
 * @param scopeInstance The request scope instance from which the request scope will
 *                      be initialized.
 * @param task          Task to be executed.
 * @param <T>           {@code task} result type.
 * @return result returned by the {@code task}
 */
public <T> T runInScope(Instance scopeInstance, Producer<T> task) {
  final Instance oldInstance = retrieveCurrent();
  try {
    setCurrent(scopeInstance.getReference());
    return Errors.process(task);
  } finally {
    scopeInstance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Runnable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestScope.Instance scope instance}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestScope.Instance scope instance} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 */
public void runInScope(Runnable task) {
  final Instance oldInstance = retrieveCurrent();
  final Instance instance = createInstance();
  try {
    setCurrent(instance);
    Errors.process(task);
  } finally {
    instance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Callable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestScope.Instance scope instance}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestScope.Instance scope instance} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(Callable<T> task) throws Exception {
  final Instance oldInstance = retrieveCurrent();
  final Instance instance = createInstance();
  try {
    setCurrent(instance);
    return Errors.process(task);
  } finally {
    instance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Runnable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestScope.Instance scope instance}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestScope.Instance scope instance} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 */
public void runInScope(Runnable task) {
  final Instance oldInstance = retrieveCurrent();
  final Instance instance = createInstance();
  try {
    setCurrent(instance);
    Errors.process(task);
  } finally {
    instance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Runnable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestScope.Instance scope instance}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestScope.Instance scope instance} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 */
public void runInScope(Runnable task) {
  final Instance oldInstance = retrieveCurrent();
  final Instance instance = createInstance();
  try {
    setCurrent(instance);
    Errors.process(task);
  } finally {
    instance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Callable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestScope.Instance scope instance}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestScope.Instance scope instance} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(Callable<T> task) throws Exception {
  final Instance oldInstance = retrieveCurrent();
  final Instance instance = createInstance();
  try {
    setCurrent(instance);
    return Errors.process(task);
  } finally {
    instance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the new request scope. The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestScope.Instance scope
 * instance}. At the end of the method the request scope is returned to its original
 * state. The newly created {@link RequestScope.Instance scope instance} will be
 * implicitly released at the end of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 */
public <T> T runInScope(Producer<T> task) {
  final Instance oldInstance = retrieveCurrent();
  final Instance instance = createInstance();
  try {
    setCurrent(instance);
    return Errors.process(task);
  } finally {
    instance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the new request scope. The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestScope.Instance scope
 * instance}. At the end of the method the request scope is returned to its original
 * state. The newly created {@link RequestScope.Instance scope instance} will be
 * implicitly released at the end of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 */
public <T> T runInScope(Producer<T> task) {
  final Instance oldInstance = retrieveCurrent();
  final Instance instance = createInstance();
  try {
    setCurrent(instance);
    return Errors.process(task);
  } finally {
    instance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the new request scope. The
 * current thread might be already in any request scope and in that case the scope
 * will be changed to the scope defined by the {@link RequestScope.Instance scope
 * instance}. At the end of the method the request scope is returned to its original
 * state. The newly created {@link RequestScope.Instance scope instance} will be
 * implicitly released at the end of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 */
public <T> T runInScope(Producer<T> task) {
  final Instance oldInstance = retrieveCurrent();
  final Instance instance = createInstance();
  try {
    setCurrent(instance);
    return Errors.process(task);
  } finally {
    instance.release();
    resumeCurrent(oldInstance);
  }
}

/**
 * Runs the {@link Callable task} in the new request scope. The current thread might
 * be already in any request scope and in that case the scope will be changed to the
 * scope defined by the {@link RequestScope.Instance scope instance}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestScope.Instance scope instance} will be implicitly released at the end
 * of the method call except the task will call
 * {@link RequestScope#suspendCurrent}.
 *
 * @param task Task to be executed.
 * @param <T>  {@code task} result type.
 * @return result returned by the {@code task}.
 * @throws Exception Exception thrown by the {@code task}.
 */
public <T> T runInScope(Callable<T> task) throws Exception {
  final Instance oldInstance = retrieveCurrent();
  final Instance instance = createInstance();
  try {
    setCurrent(instance);
    return Errors.process(task);
  } finally {
    instance.release();
    resumeCurrent(oldInstance);
  }
}

Popular methods of RequestScope

current
referenceCurrent
Get a new reference for to currently running request scope instance. This call prevents automatic Re
runInScope
Runs the org.glassfish.jersey.internal.util.Producer in the request scope initialized from the Reque
retrieveCurrent
<init>
activate
Stores the provided RequestContext to thread-local variable belonging to current request scope.
createContext
Creates a new instance of the RequestContext. This instance can be then used to run task in the requ
release
Releases the provided RequestContext to thread-local variable belonging to current request scope.
resume
Resumes the provided RequestContext to thread-local variable belonging to current request scope.
createInstance
Creates a new instance of the RequestScope.Instance. This instance can be then used to run task in t
isActive
setCurrent

Popular in Java

Reactive rest calls using spring rest template
putExtra (Intent)
setContentView (Activity)
getApplicationContext (Context)
Date (java.util)
A specific moment in time, with millisecond precision. Values typically come from System#currentTime
Deque (java.util)
A linear collection that supports element insertion and removal at both ends. The name deque is shor
Locale (java.util)
Locale represents a language/country/variant combination. Locales are used to alter the presentatio
ResourceBundle (java.util)
ResourceBundle is an abstract class which is the superclass of classes which provide Locale-specifi
Executor (java.util.concurrent)
An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
ExecutorService (java.util.concurrent)
An Executor that provides methods to manage termination and methods that can produce a Future for tr
Top 12 Jupyter Notebook Extensions

How to use resumeCurrentmethodin org.glassfish.jersey.process.internal.RequestScope

Best Java code snippets using org.glassfish.jersey.process.internal.RequestScope.resumeCurrent (Showing top 18 results out of 315)

How to use
resumeCurrent
method
in
org.glassfish.jersey.process.internal.RequestScope