Tabnine Logo
RequestScope.retrieveCurrent
Code IndexAdd Tabnine to your IDE (free)

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

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

origin: jersey/jersey

final RequestContext context = retrieveCurrent();
if (context == null) {
  return null;
origin: jersey/jersey

final RequestContext context = retrieveCurrent();
if (context == null) {
  return null;
origin: jersey/jersey

/**
 * 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 RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} 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 RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} 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 RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 */
public void runInScope(RequestContext context, Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * 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 RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} 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 RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} 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 RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 */
public void runInScope(RequestContext context, Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the request scope initialized
 * from the {@link RequestContext scope context}.
 * The {@link RequestContext scope context} 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 RequestContext scope context}. At the end of the method the request
 * scope is returned to its original state.
 *
 * @param context The request scope context 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(RequestContext context, Producer<T> task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * Runs the {@link Callable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} 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 RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context 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(RequestContext context, Callable<T> task) throws Exception {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * Runs the {@link org.glassfish.jersey.internal.util.Producer task} in the request scope initialized
 * from the {@link RequestContext scope context}.
 * The {@link RequestContext scope context} 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 RequestContext scope context}. At the end of the method the request
 * scope is returned to its original state.
 *
 * @param context The request scope context 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(RequestContext context, Producer<T> task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * 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 RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state. The newly created {@link RequestContext scope context} 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 RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * 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 RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state. The newly created {@link RequestContext scope context} 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 RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * 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 RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} 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 RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * 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 RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} 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 RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: jersey/jersey

/**
 * Runs the {@link Callable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} 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 RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context 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(RequestContext context, Callable<T> task) throws Exception {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    return Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: hstaudacher/osgi-jax-rs-connector

/**
 * 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);
  }
}
origin: org.glassfish.jersey.core/jersey-common

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} 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 RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 */
public void runInScope(RequestContext context, Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: org.glassfish.jersey.core/jersey-common

/**
 * 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 RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} 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 RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: hstaudacher/osgi-jax-rs-connector

/**
 * 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);
  }
}
origin: org.glassfish.jersey.bundles/jaxrs-ri

/**
 * Runs the {@link Runnable task} in the request scope initialized from the
 * {@link RequestContext scope context}. The {@link RequestContext
 * scope context} 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 RequestContext scope
 * instance}. At the end of the method the request scope is returned to its original
 * state.
 *
 * @param context The request scope context from which the request scope will be initialized.
 * @param task    Task to be executed.
 */
public void runInScope(RequestContext context, Runnable task) {
  final RequestContext oldContext = retrieveCurrent();
  try {
    activate(context.getReference(), oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
origin: org.glassfish.jersey.bundles/jaxrs-ri

/**
 * 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 RequestContext scope context}. At the end of
 * the method the request scope is returned to its original state. The newly created
 * {@link RequestContext scope context} 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 RequestContext oldContext = retrieveCurrent();
  final RequestContext context = createContext();
  try {
    activate(context, oldContext);
    Errors.process(task);
  } finally {
    release(context);
    resume(oldContext);
  }
}
org.glassfish.jersey.process.internalRequestScoperetrieveCurrent

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
  • <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
  • resumeCurrent
  • setCurrent
  • resumeCurrent,
  • setCurrent,
  • shutdown,
  • suspend

Popular in Java

  • Start an intent from android
  • onCreateOptionsMenu (Activity)
  • putExtra (Intent)
  • setContentView (Activity)
  • PrintWriter (java.io)
    Wraps either an existing OutputStream or an existing Writerand provides convenience methods for prin
  • DecimalFormat (java.text)
    A concrete subclass of NumberFormat that formats decimal numbers. It has a variety of features desig
  • BitSet (java.util)
    The BitSet class implements abit array [http://en.wikipedia.org/wiki/Bit_array]. Each element is eit
  • Queue (java.util)
    A collection designed for holding elements prior to processing. Besides basic java.util.Collection o
  • SortedSet (java.util)
    SortedSet is a Set which iterates over its elements in a sorted order. The order is determined eithe
  • Join (org.hibernate.mapping)
  • Top Sublime Text plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now