# tag::registering-incremental-annotation-processors[]
org.gradle.EntityProcessor,isolating
org.gradle.ServiceRegistryProcessor,dynamic

org.gradle.internal.instrumentation.processor.ConfigurationCacheInstrumentationProcessor,aggregating...

    def "detects no processors in broken jars"() {
        given:
        def jar = tmpDir.file("classes.jar")
        jar << "broken"
        def cp = files(jar)

        when:
        def processors = detector.detectProcessors(cp)

        then:
        processors == [:]
        1 * logger.warn({ it.contains("no annotation processors") }, { it.message.contains("Error reading Zip") })
    }

        }

        TestClassProcessor processor;
        if (processors.size() < maxProcessors) {
            processor = factory.create();
            rawProcessors.add(processor);
            Actor actor = actorFactory.createActor(processor);
            processor = actor.getProxy(TestClassProcessor.class);
            actors.add(actor);
            processors.add(processor);
            processor.startProcessing(resultProcessor);

        Map<String, AnnotationProcessorDeclaration> processors = new LinkedHashMap<>();
        for (File jarOrClassesDir : processorPath) {
            for (AnnotationProcessorDeclaration declaration : cache.get(jarOrClassesDir)) {
                String className = declaration.getClassName();
                if (!processors.containsKey(className)) {
                    processors.put(className, declaration);
                }
            }

                Processor processor = instantiateProcessor(processorClass);
                supportedOptionsCollectingProcessor.addProcessor(processor);
                processor = decorateForIncrementalProcessing(processor, declaredProcessor.getType(), processorResult);
                processor = decorateForTimeTracking(processor, processorResult);
                processors.add(processor);
            }

        private final List<OperationResultPostProcessor> processors;

        public PostProcessors(List<OperationResultPostProcessor> processors) {
            this.processors = processors;
        }

        @Override
        public void started(BuildOperationDescriptor buildOperation, OperationStartEvent startEvent) {
            for (OperationResultPostProcessor processor : processors) {

 * when combined with {@code -Werror}.
 *
 * <p>This processor needs to be added last to make sure that all other processors
 * have been {@linkplain Processor#init(ProcessingEnvironment) initialized} when
 * {@link #getSupportedOptions()} is called.
 */
public class SupportedOptionsCollectingProcessor extends AbstractProcessor {
    private final List<Processor> processors = new ArrayList<Processor>();

    public void addProcessor(Processor processor) {

import org.gradle.api.internal.tasks.testing.processors.MaxNParallelTestClassProcessor;
import org.gradle.api.internal.tasks.testing.processors.PatternMatchTestClassProcessor;
import org.gradle.api.internal.tasks.testing.processors.RestartEveryNTestClassProcessor;
import org.gradle.api.internal.tasks.testing.processors.RunPreviousFailedFirstTestClassProcessor;
import org.gradle.api.internal.tasks.testing.processors.TestMainAction;

	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"]
}