import javax.annotation.Nullable;
import java.util.Map;

/**
 * Immutable set of Gradle properties loaded at the start of the build.
 */
public interface GradleProperties {

    @Nullable
    Object find(String propertyName);

    /**
     * Merges the loaded properties with the given properties and returns an immutable
     * map with the result.
     *

     * specific moment. The implementation may return different values at different times.
     */
    boolean interceptsPropertyAccess(String propertyName);

            unfilteredAfterExecutionSnapshots,
            (propertyName, unfilteredAfterExecution) -> {
                // This can never be null as it comes from an ImmutableMap's value
                assert unfilteredAfterExecution != null;

                FileSystemSnapshot previous = previousSnapshots.get(propertyName);

                if (viewType.equals(viewSchema.getType())) {
                    for (ModelProperty<?> property : viewSchema.getProperties()) {
                        String propertyName = property.getName();
                        viewPropertiesByNameBuilder.put(propertyName, property);
                    }
                    for (WeaklyTypeReferencingMethod<?, ?> viewMethod : viewSchema.getAllMethods()) {

            this.changeContainerDelegate = changeContainerDelegate;
        }

        @Override
        public boolean accept(String propertyName, ChangeVisitor visitor) {
            return inputFileChangesDelegate.accept(propertyName, visitor);
        }

        @Override
        public boolean accept(ChangeVisitor visitor) {
            return changeContainerDelegate.accept(visitor);
        }

        return getters.map { (name, getter) ->
            checkNotNull(getter)
            val nameAfterGet = name.substringAfter("get")
            val propertyName = nameAfterGet.replaceFirstChar { it.lowercase(Locale.getDefault()) }
            val type = propertyValueType(getter.returnType).toDataTypeRefOrError()

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Configuring {
    String propertyName() default "";

        super(annotationType, Kind.OTHER, ImmutableSet.of());
    }
    @Override
    public boolean isPropertyRelevant() {
        return false;
    }

    @Override
    public void visitPropertyValue(String propertyName, PropertyValue value, PropertyMetadata propertyMetadata, PropertyVisitor visitor) {
    }

            }

            @Override
            void visitRegularInputs(UnitOfWork.InputVisitor visitor) {
                inputProperties.each { propertyName, value ->
                    visitor.visitInputProperty(propertyName, () -> value)
                }
                for (entry in inputFiles.entrySet()) {
                    visitor.visitInputFileProperty(
                        entry.key,

                with(it.find { it instanceof Map && it['propertyName'] == 'stableClasspath' }, Map) {
                    files.collect { new File(it as String) }.containsAll(expectedClasspath)
                }
            }
            with(outputFileProperties, List) {
                !empty
                with(it.find { it instanceof Map && it['propertyName'] == 'reports.enabledReports.html.outputLocation' }, Map) {