}
    }

    /**
     * Contains the types generated by isolating annotation processors, grouped by the type they were generated from.
     */
    public Map<String, Set<String>> getGeneratedTypesWithIsolatedOrigin() {
        return generatedTypesByOrigin;
    }

    /**
     * Contains the resources generated by isolating annotation processors, grouped by the type they were generated from.
     */

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;

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

func (cs *callbacks) Row() *processor {
	return cs.processors["row"]
}

import java.util.List;

@ServiceScope(Scope.Global.class)
public interface OperationResultPostProcessorFactory {
    /**
     * Creates the post processors relevant for the given subscriptions. The processors are also registered as listeners.
     */
    List<OperationResultPostProcessor> createProcessors(BuildEventSubscriptions subscriptions, BuildEventConsumer consumer);

[[annotation_processors]]
=== Annotation processors

Compile avoidance works out of the box.
There is one caveat though: when using annotation processors, Gradle uses the annotation processor classpath as an input.

    def "when neither processor path nor processor option are given, no processors are used"() {
        when:
        compiler.execute(spec)
        then:
        spec.effectiveAnnotationProcessors == [] as Set
    }

    def "when only processor path is given, all processors on the path are used"() {
        given:
        def proc1 = Stub(AnnotationProcessorDeclaration)

```yaml
receivers:
  otlp:
    protocols:
      grpc:
      http:
processors:
  batch:
exporters:
  logging:
    loglevel: debug
service:
  pipelines:
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [logging]
```

## Update Istio configmap

Run the following script to update the `istio` with demo profile:

    }

    @Override
    public void addModules(Iterable<String> moduleNames) {
    }

    @Override
    public void setProcessors(Iterable<? extends Processor> processors) {
        delegate.setProcessors(processors);
    }

    @Override
    public void setLocale(Locale locale) {
        delegate.setLocale(locale);
    }

    @Override
    public Boolean call() {
        try {

    }

    public interface Result {

        /**
         * Returns details about the used annotation processors, if available.
         *
         * <p>Details are only available if an instrumented compiler was used.
         *
         * @return details about used annotation processors; {@code null} if unknown.
         */
        @Nullable
        List<AnnotationProcessorDetails> getAnnotationProcessorDetails();

    @Rule public final Sample processing = new Sample(temporaryFolder, 'java/incrementalAnnotationProcessing')

    def "isolating annotation processors are incremental"() {
        given:
        CompilationOutputsFixture outputs = new CompilationOutputsFixture(processing.dir.file("groovy/user/build/classes"))
        outputs.snapshot { compile() }

        when: