/**
     * Contains the types that aggregating annotation processors registered themselves for.
     * These types need to be reprocessed no matter what source changes are made to ensure that the generated types contain all relevant information.
     */
    public Set<String> getAggregatedTypes() {
        return aggregatedTypes;
    }

    /**
     * Contains the types that aggregating annotation processors generated.

                boolean aggregating = mojoDescriptor.isAggregator() || !mojoDescriptor.isProjectRequired();

                if (currentSegment == null || currentSegment.isAggregating() != aggregating) {
                    currentSegment = new TaskSegment(aggregating);
                    taskSegments.add(currentSegment);
                }

            }
        }

        doExecute(session, mojoExecution, dependencyContext);
    }

    /**
     * Aggregating mojo executions (possibly) modify all MavenProjects, including those that are currently in use
     * by concurrently running mojo executions. To prevent race conditions, an aggregating execution will block
     * all other executions until finished.

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

            }

            private AnnotationProcessorDetails.Type toType(IncrementalAnnotationProcessorType type) {
                if (type == IncrementalAnnotationProcessorType.AGGREGATING) {
                    return AnnotationProcessorDetails.Type.AGGREGATING;
                }
                if (type == IncrementalAnnotationProcessorType.ISOLATING) {
                    return AnnotationProcessorDetails.Type.ISOLATING;
                }

            logger.debug("Tasks:   " + projectBuild.getTaskSegment().getTasks());
            logger.debug("Style:   " + (projectBuild.getTaskSegment().isAggregating() ? "Aggregating" : "Regular"));

            if (it.hasNext()) {
                logger.debug("-----------------------------------------------------------------------");
            }
        }

    AggregatingProcessor processor = new AggregatingProcessor(delegate, processorResult)

    def "sets processor type"() {
        expect:
        processorResult.type == IncrementalAnnotationProcessorType.AGGREGATING
    }

    def "when delegate reacts to any class, all root elements are aggregated"() {
        given:
        delegate.getSupportedAnnotationTypes() >> ["*"]

        when:

// See the License for the specific language governing permissions and
// limitations under the License.

// Package config is a common, top-level folder for aggregating Istio-wide config related libraries and utilities.
// More details can be found here: https://docs.google.com/document/d/1atY5vDHy5sXJP7qIaFQS3ixQZvOxUciPgULH5qTPX_8/

        then:
        1 * listener.onAccess('missing')
        then:
        1 * listener.onRemove('missing')
        then:
        0 * listener._
    }

    def "method #methodName is reported as aggregating"() {
        when:
        operation.accept(set)

        then:
        (1.._) * listener.onAggregatingAccess()
        0 * listener._

        where:
        methodName            | operation

 * See the user guide chapter on incremental annotation processing for more information.
 */
public enum IncrementalAnnotationProcessorType {
    ISOLATING,
    AGGREGATING,
    DYNAMIC,
    UNKNOWN;

    public String getProcessorOption() {
        return "org.gradle.annotation.processing." + name().toLowerCase(Locale.ROOT);
    }