import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.TypeElement;
import java.util.Set;


/**
 * An aggregating processor can have zero to many originating elements for each generated file.
 */
public final class AggregatingProcessor extends DelegatingProcessor {

    private final IncrementalProcessingStrategy strategy;

package org.gradle.launcher.daemon.server.expiry;

/**
 * Expiration status for daemon expiration check results.  Note that order here is important, higher ordinal statuses take precedent over lower ordinal statuses when aggregating results in {@link
 * AllDaemonExpirationStrategy}.
 */
public enum DaemonExpirationStatus {
    DO_NOT_EXPIRE,
    QUIET_EXPIRE,
    GRACEFUL_EXPIRE,
    IMMEDIATE_EXPIRE;

    interface InternalAnnotationProcessorResult extends InternalProtocolInterface {

        String TYPE_ISOLATING = "ISOLATING";
        String TYPE_AGGREGATING = "AGGREGATING";
        String TYPE_UNKNOWN = "UNKNOWN";

        String getClassName();

        String getType();

        Duration getDuration();

    }

            delegate = new IsolatingProcessingStrategy(result);
        } else if (supportedOptions.contains(IncrementalAnnotationProcessorType.AGGREGATING.getProcessorOption())) {
            delegate = new AggregatingProcessingStrategy(result);
        }
    }

    @Override

import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.TypeElement;
import java.util.Set;

/**
 * An annotation processor which can decide whether it is isolating, aggregating or non-incremental at runtime.
 * It needs to return its type through the {@link #getSupportedOptions()} method in the format defined by
 * {@link IncrementalAnnotationProcessorType#getProcessorOption()}.
 */

            public void hasChanged() {}
        }
        """
        compile()

        then:
        outputs.recompiledClasses("Entity1", "Entity1Repository", "ServiceRegistry", "Main")
    }

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

         */
        Duration getDuration();

        /**
         * Type of annotation processor.
         *
         * @since 5.1
         */
        enum Type {
            ISOLATING,
            AGGREGATING,
            UNKNOWN
        }
    }

    PackageInfoGeneratedClassProcessorFixture() {
        super("com.my.processor", "Configuration")
        declaredType = IncrementalAnnotationProcessorType.AGGREGATING
    }

    @Override
    String getDependenciesBlock() {
        """
            implementation 'org.ow2.asm:asm:9.0'
        """
    }

    @Override
    String getRepositoriesBlock() {

            /**
             * Type of annotation processor.
             *
             * @see IncrementalAnnotationProcessorType
             */
            enum Type {
                ISOLATING, AGGREGATING, UNKNOWN
            }

        }

    }

    }

    /**
     * Returns the types that need to be reprocessed based on which classes are due to be recompiled. This includes:
     *
     * - types which are annotated with aggregating annotations, as aggregating processors need to see them regardless of what has changed
     * - the originating types of generated classes that need to be recompiled, since they wouldn't exist if the originating type is not reprocessed
     */