match     func(*DB) bool
	handler   func(*DB)
	processor *processor
}

func (cs *callbacks) Create() *processor {
	return cs.processors["create"]
}

func (cs *callbacks) Query() *processor {
	return cs.processors["query"]
}

func (cs *callbacks) Update() *processor {
	return cs.processors["update"]
}

func (cs *callbacks) Delete() *processor {
	return cs.processors["delete"]
}

        try (RankFusionProcessor processor = new RankFusionProcessor()) {
            processor.setSearcher(new TestSearcher(100));
            processor.register(new TestSearcher(0)); // Empty searcher
            processor.register(new TestSearcher(50)); // Half-full searcher
            processor.init();

            processor = ProcessorHolder.CACHED_PROCESSOR.get();
        }
        return processor.process(object);
    }

    /**
     * Load the first available processor implementation.
     */
    private static ModelObjectProcessor loadProcessor() {
        /*
         * No-op processor that returns objects unchanged.
         */
        class NoOpProcessor implements ModelObjectProcessor {

        try (RankFusionProcessor processor = new RankFusionProcessor()) {
            processor.setSearcher(new TestSearcher(100));
            processor.register(new NullDocumentSearcher());
            processor.init();

            // Should handle null documents gracefully
            final List<Map<String, Object>> results = processor.search("*", new TestSearchRequestParams(0, 10, 0), OptionalThing.empty());

            this.modularJar = requireType(Type.MODULAR_JAR);
            this.processor = requireType(Type.PROCESSOR);
            this.classpathProcessor = requireType(Type.CLASSPATH_PROCESSOR);
            this.modularProcessor = requireType(Type.MODULAR_PROCESSOR);
            this.needsDerive = Set.of(Type.PROCESSOR, Type.CLASSPATH_PROCESSOR, Type.MODULAR_PROCESSOR);
            this.stack = new ArrayDeque<>();
        }

        final CountDownLatch endLatch = new CountDownLatch(numThreads);
        final AtomicInteger registeredCount = new AtomicInteger(0);

        try (RankFusionProcessor processor = new RankFusionProcessor()) {
            processor.setSearcher(new TestSearcher(100));
            processor.init();

            final ExecutorService executor = Executors.newFixedThreadPool(numThreads);
            try {
                for (int i = 0; i < numThreads; i++) {

    /**
     * Artifact type name for a JAR file that can be placed either on the annotation processor class path
     * or module path. The path (classes or modules) is chosen by the plugin, possibly using heuristic rules.
     */
    String PROCESSOR = "processor";

    /**
     * Artifact type name for a JAR file to unconditionally place on the annotation processor class path.
     * If the JAR is modular, its module information are ignored.
     */

 */
package org.codelibs.fess.crawler.processor;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.fess.crawler.entity.AccessResult;
import org.codelibs.fess.crawler.entity.ResponseData;
import org.codelibs.fess.crawler.entity.ResultData;
import org.codelibs.fess.crawler.processor.impl.DefaultResponseProcessor;
import org.codelibs.fess.ingest.IngestFactory;

                    java.util.function.BiFunction<org.opensearch.action.update.UpdateRequestBuilder, org.opensearch.search.SearchHit, org.opensearch.action.update.UpdateRequestBuilder> processor) {
                // Return a fixed count for testing
                return 3L;
            }
        };
        ComponentUtil.register(mockSearchEngineClient, "searchEngineClient");

        // Mock FessConfig

import org.opensearch.index.query.QueryBuilder;

import jakarta.annotation.PostConstruct;

/**
 * Query processor component that handles query filters and commands.
 * 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