List<String> list =
        source.readLines(
            new LineProcessor<List<String>>() {
              final List<String> list = new ArrayList<>();

              @Override
              public boolean processLine(String line) throws IOException {
                list.add(line);
                return true;
              }

              @Override
              public List<String> getResult() {

    return readLines(
        url,
        charset,
        new LineProcessor<List<String>>() {
          final List<String> result = new ArrayList<>();

          @Override
          public boolean processLine(String line) {
            result.add(line);
            return true;
          }

          @Override
          public List<String> getResult() {
            return result;
          }
        });

    LineProcessor<List<String>> collectAndLowercaseAndTrim =
        new LineProcessor<List<String>>() {
          final List<String> collector = new ArrayList<>();

          @Override
          public boolean processLine(String line) {
            collector.add(whitespace().trimFrom(line));
            return true;
          }

          @Override
          public List<String> getResult() {
            return collector;

Guillaume Nodet <******@****.***> 1725988727 +0200

 * the delay intervals in a web crawler. It includes constants representing
 * different types of processing states and a method to introduce a delay
 * based on the type of processing.
 * <p>
 * Constants:
 * </p>
 * <ul>
 *   <li>{@code PRE_PROCESSING} - Represents the pre-processing state.</li>
 *   <li>{@code POST_PROCESSING} - Represents the post-processing state.</li>

     */
    public long getDelayMillisAfterProcessing() {
        return delayMillisAfterProcessing;
    }

    /**
     * Sets the delay time in milliseconds after processing a URL.
     *
     * @param delayMillisAfterProcessing the delay time in milliseconds after processing
     */
    public void setDelayMillisAfterProcessing(final long delayMillisAfterProcessing) {

         */
        REP result,

        /**
         * Any error that occurred during processing; null if the request was successful
         */
        Throwable error) {

    /**
     * Determines if the request was processed successfully.
     *
     * @return true if no error occurred during processing (error is null), false otherwise
     */
    public boolean isSuccess() {
        return error == null;

    }

    /**
     * Gets the total processing time for all documents in this list.
     *
     * @return the total processing time in milliseconds
     */
    public long getProcessingTime() {
        return processingTime;
    }

    /**
     * Adds to the total processing time of this document list.
     *
     * @param processingTime the processing time to add in milliseconds
     */

 * This class provides a pipeline for processing Lucene queries by applying
 * a chain of filters and executing registered query commands.
 *
 * <p>The processor maintains a map of query commands indexed by query class names
 * and a list of filters that are applied in order during query processing.</p>
 */
public class QueryProcessor {

    /**
     * Default constructor.
     */

 * It allows setting delays before processing, after processing, when no URLs are in the queue,
 * and when waiting for new URLs.
 * The delays are configurable via constructor parameters.
 *
 */
public class DefaultIntervalController extends AbstractIntervalController {

    /** Delay in milliseconds after processing a URL */
    protected long delayMillisAfterProcessing = 0L;