*/
    public DefaultResponseProcessor() {
        // Default constructor
    }

    /**
     * Processes response data based on HTTP status code and configured transformer.
     *
     * @param responseData the response data to process
     */
    @Override
    public void process(final ResponseData responseData) {
        if (isNotModified(responseData)) {

 * and processing them according to specific rules. The main functionality is encapsulated
 * within the nested {@link TextNormalizeContext} class.
 *
 * <p>The text normalization process includes:
 * <ul>
 *   <li>Treating ISO control characters and specified space characters as spaces.</li>
 *   <li>Appending alphanumeric characters (0-9, A-Z, a-z) to the buffer.</li>

        try {
            jobHelper.setJobRuntime(runtime);
            process(runtime);
        } finally {
            jobHelper.setJobRuntime(null);
        }
    }

    /**
     * Processes the job.
     * @param runtime The job runtime.
     */
    protected void process(final LaJobRuntime runtime) {
        if (!runtime.getParameterMap().containsKey(Constants.SCHEDULED_JOB)) {

    /**
     * Constructs a new SSO process exception with the specified detailed message.
     *
     * @param message The detailed error message explaining the cause of the exception
     */
    public SsoProcessException(final String message) {
        super(message);
    }

    /**
     * Constructs a new SSO process exception with the specified detailed message and cause.
     *

/**
 * A thread that reads from an input stream line by line and maintains a buffer of recent lines.
 * This class provides functionality to read input stream data asynchronously,
 * optionally process each line with a callback function, and maintain a circular buffer
 * of recent lines for retrieval.
 */
public class InputStreamThread extends Thread {
    /** Logger instance for this class */

        }

        return -1;
    }

    /**
     * Processes a single crawl request by executing the HTTP request, handling redirects,
     * transforming the response data, and indexing the document.
     *
     * @param paramMap the data store parameters
     * @param dataMap the data map to be updated with response data
     * @param url the URL to process
     * @param client the crawler client to use for the request

     * @return True if processing was successful, false otherwise.
     */
    protected boolean process(final String id, final Predicate<ResponseData> consumer) {
        return process(id, (configId, url) -> {
            final CrawlingConfigHelper crawlingConfigHelper = ComponentUtil.getCrawlingConfigHelper();
            final CrawlingConfig config = crawlingConfigHelper.getCrawlingConfig(configId);

                    entity.getBoost(), false);
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
        }

        }

        /**
         * Executes the crawling thread.
         * Sets the running flag, processes the data store, and ensures
         * proper cleanup regardless of success or failure.
         */
        @Override
        public void run() {
            running = true;
            try {
                process();
            } finally {
                running = false;
                finished = true;

    protected static final String ACCESS_CONTROL_MAX_AGE = "Access-Control-Max-Age";

    /**
     * Processes the CORS request by setting appropriate headers.
     *
     * @param origin the origin of the request
     * @param request the servlet request
     * @param response the servlet response
     */
    public abstract void process(String origin, ServletRequest request, ServletResponse response);