// Create multiple threads adding patterns
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                urlFilter.addInclude("https://site" + i + ".com/.*");
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                urlFilter.addExclude(".*\\.type" + i + "$");
            }
        });

    /**
     * Test thread safety of enum
     */
    public void test_threadSafety() throws Exception {
        final int threadCount = 100;
        final int iterationsPerThread = 1000;
        final Set<Exception> exceptions = new HashSet<>();

        Thread[] threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override

 *   <li>Processing the response using a {@link ResponseProcessor} associated with a {@link Rule}.</li>
 *   <li>Extracting child URLs and adding them to the queue using {@link #storeChildUrls(Set, String, int)}
 *       or {@link #storeChildUrl(String, String, float, int)}.</li>
 *   <li>Handling exceptions that may occur during the crawling process.</li>
 * </ol>
 *
 * <p>

            }
        }

        LogStream.setInstance(new PrintStream(new OutputStream() {
            private static final int MAX_LEN = 1000;

            private final ByteArrayOutputStream buf = new ByteArrayOutputStream(MAX_LEN);

            @Override
            public void write(final int b) throws IOException {
                if (b == '\n' || b == '\r' || buf.size() >= MAX_LEN) {
                    try {

    /** List of registered crawler client factories */
    protected List<CrawlerClientFactory> clientFactoryList = new LinkedList<>();

    /**
     * The maximum size of the client factory list.
     */
    protected int maxClientFactorySize = 10000;

    /**
     * Registers a CrawlerClientFactory with this creator.
     * All existing client mappings will be loaded into the new factory.

     * @return An empty map.
     */
    protected Map<String, Object> createEmptyMap() {
        final Map<String, Object> map = new HashMap<>();
        map.put(FieldNames.TEXT, StringUtil.EMPTY);

        for (int i = 0; i < readings.length; i++) {
            map.put(FieldNames.READING_PREFIX + i, new String[] {});
        }

        map.put(FieldNames.FIELDS, new String[] {});
        map.put(FieldNames.TAGS, new String[] {});

import org.opensearch.index.IndexSettings;
import org.opensearch.index.analysis.AbstractTokenFilterFactory;

public class KuromojiKatakanaStemmerFactory extends AbstractTokenFilterFactory {

    private final int minimumLength;

    public KuromojiKatakanaStemmerFactory(IndexSettings indexSettings, Environment environment, String name, Settings settings) {
        super(indexSettings, name, settings);

    protected Map<String, QueueHolder> sessionCache = new ConcurrentHashMap<>();

    /**
     * The number of URLs to fetch when polling.
     */
    protected int pollingFetchSize = 1000;

    /**
     * The maximum size of the crawling queue.
     */
    protected int maxCrawlingQueueSize = 100;

    /**
     * Creates a new instance of OpenSearchUrlQueueService.
     * @param crawlerConfig The crawler configuration.
     */

 */
public interface ReadingConverter {

    /**
     * Returns the maximum number of readings.
     *
     * @return the maximum number of readings, default is 10.
     */
    default int getMaxReadingNum() {
        return 10;
    }

    /**
     * Initializes the converter.
     *
     * @throws IOException if an I/O error occurs during initialization.
     */

        } else {
            stopwords = new String[0];
        }

        ignoreCase = settings.getAsBoolean("ignore_case", Boolean.FALSE).booleanValue();
        if (ignoreCase) {
            for (int i = 0; i < stopwords.length; i++) {
                stopwords[i] = stopwords[i].toLowerCase(Locale.ROOT);
            }
        }
    }

    @Override
    public TokenStream create(final TokenStream tokenStream) {