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

Reading from database using SQL prepared statement
runOnUiThread (Activity)
getSharedPreferences (Context)
scheduleAtFixedRate (Timer)
BufferedWriter (java.io)
Wraps an existing Writer and buffers the output. Expensive interaction with the underlying reader is
Runnable (java.lang)
Represents a command that can be executed. Often used to run code in a different Thread.
BigInteger (java.math)
An immutable arbitrary-precision signed integer.FAST CRYPTOGRAPHY This implementation is efficient f
SocketTimeoutException (java.net)
This exception is thrown when a timeout expired on a socket read or accept operation.
ArrayList (java.util)
ArrayList is an implementation of List, backed by an array. All optional operations including adding
Iterator (java.util)
An iterator over a sequence of objects, such as a collection.If a collection has been changed since

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