return destroyProcess(sessionId, jobProcess);
    }

    /**
     * Checks if any processes are currently running.
     *
     * @return true if at least one process is running, false otherwise
     */
    public boolean isProcessRunning() {
        return !runningProcessMap.isEmpty();
    }

    /**
     * Checks if the process with the given session ID is currently running.
     *

 * asynchronous response handling and response chaining capabilities.
 *
 * @author mbechler
 */
public interface CommonServerMessageBlockResponse extends CommonServerMessageBlock, Response {

    /**
     * Checks if this is an asynchronous response.
     *
     * @return is an async response
     */
    boolean isAsync();

    /**
     *
     * @return the next response
     */
    @Override

    protected String encodePath(final String path) {
        return Base64.getUrlEncoder().encodeToString(path.getBytes(Constants.CHARSET_UTF_8));
    }

    /**
     * Checks if the given path matches this creator's pattern.
     *
     * @param path the file path to check
     * @return true if the path matches the pattern, false otherwise
     */
    protected boolean isTarget(final String path) {
        return pattern.matcher(path).find();

  }

  /**
   * Test EqualsTester with no equals or not equals objects. This checks proper handling of null,
   * incompatible class and reflexive tests
   */
  public void testTestEqualsEmptyLists() {
    equalsTester.addEqualityGroup(reference);
    equalsTester.testEquals();
  }

  /**
   * Test EqualsTester after populating equalObjects. This checks proper handling of equality and
   * verifies hashCode for valid objects

     *
     * @param statusCode the HTTP status code to set
     */
    public void setHttpStatusCode(final int statusCode) {
        httpStatusCode = statusCode;
    }

    /**
     * Checks if this response has a response body.
     *
     * @return true if the response has a body (either as bytes or file), false otherwise
     */
    public boolean hasResponseBody() {

            context.invalidate();
            log.debug("Finalized preauth integrity context for session {}", sessionId);
        }
    }

    /**
     * Checks if a hash algorithm is supported.
     *
     * @param hashAlgorithm the algorithm to check
     * @return true if supported
     */
    public boolean isHashAlgorithmSupported(int hashAlgorithm) {

        if (contextHandle == null) {
            contextHandle = new byte[20];
        }
        buf.readOctetArray(contextHandle, 0, 20);
    }

    /**
     * Checks if the context handle has been invalidated (all zeros).
     * A successful unregistration typically results in a zeroed context handle.
     *
     * @return true if the context handle has been invalidated
     */

   * compatibility problems on Android VMs. The corresponding accessor method, however, can have the
   * more specific return type as long as users are careful to guard calls to it with version checks
   * or reflection: Android VMs ignore the types of elements that aren't used.
   */
  private final @Nullable Object annotatedType;

  Parameter(
      Invokable<?, ?> declaration,
      int position,

 * Implementations of this interface handle specific types of web API requests
 * by matching incoming requests and processing them accordingly.
 */
public interface WebApiManager {

    /**
     * Checks if the request matches this API manager.
     * @param request The HTTP servlet request.
     * @return True if the request matches, false otherwise.
     */
    boolean matches(HttpServletRequest request);

    /**

    /**
     * Gets the URL where the crawling error occurred.
     *
     * @return the URL associated with this exception
     */
    public String getUrl() {
        return url;
    }

    /**
     * Checks whether the crawling process should be aborted due to this exception.
     *
     * @return true if the crawling should be aborted, false otherwise
     */
    public boolean aborted() {
        return abort;
    }