/**
 * Actually executes the build.
 *
 * Typically the last action in the pipeline.
 */
public class ExecuteBuild extends BuildCommandOnly {

    private static final Logger LOGGER = Logging.getLogger(ExecuteBuild.class);

    final private BuildActionExecutor<BuildActionParameters, BuildRequestContext> actionExecuter;
    private final DaemonRunningStats runningStats;

import java.util.function.Consumer;

public class DefaultPersistentDirectoryCache extends DefaultPersistentDirectoryStore implements ReferencablePersistentCache {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultPersistentDirectoryCache.class);

    private final Properties properties = new Properties();
    private final Consumer<? super PersistentCache> initAction;

    public DefaultPersistentDirectoryCache(

 *
 * <p>Currently, dispatch is thread safe, and receive is not.
 */
public class DaemonClientConnection implements Connection<Message> {
    private final static Logger LOG = Logging.getLogger(DaemonClientConnection.class);
    private final RemoteConnection<Message> connection;
    private final DaemonConnectDetails daemon;
    private final StaleAddressDetector staleAddressDetector;
    private boolean hasReceived;

                return new AnnotationProcessorDetector(cacheFactory, LoggerFactory.getLogger(AnnotationProcessorDetector.class), loggingConfiguration.getShowStacktrace() != ShowStacktrace.INTERNAL_EXCEPTIONS);
            }
        });
    }

            getClientMetaData(),
            getOutputFile(),
            getTextOutputFactory()
        );
    }

    void logClickableOutputFileUrl() {
        if (shouldCreateReportFile()) {
            getLogger().lifecycle("See the report at: {}", clickableOutputFileUrl());
        }
    }

    String clickableOutputFileUrl() {
        return new ConsoleRenderer().asClickableFileUrl(getOutputFile());
    }

public class FileSystemServices implements ServiceRegistrationProvider {
    private static final Logger LOGGER = LoggerFactory.getLogger(FileSystemServices.class);

    public void configure(ServiceRegistration registration) {
        registration.add(GenericFileSystem.Factory.class);
        registration.add(StatStatistics.Collector.class);
    }

 */
public class ThrottlingOutputEventListener implements OutputEventListener {
    private static final Logger LOGGER = LoggerFactory.getLogger(ThrottlingOutputEventListener.class);

    private final OutputEventListener listener;

    private final ScheduledExecutorService executor;
    private final Clock clock;
    private final int throttleMs;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Supplier;

public class CachedStoreFactory<T> implements Closeable {

    private static final Logger LOG = Logging.getLogger(CachedStoreFactory.class);
    private static final int CACHE_SIZE = Integer.getInteger("org.gradle.api.internal.artifacts.ivyservice.resolveengine.store.cacheSize", 100);

public class SkipUpToDateStep<C extends IncrementalChangesContext> implements Step<C, UpToDateResult> {
    private static final Logger LOGGER = LoggerFactory.getLogger(SkipUpToDateStep.class);

    private final Step<? super C, ? extends AfterExecutionResult> delegate;

    public SkipUpToDateStep(Step<? super C, ? extends AfterExecutionResult> delegate) {
        this.delegate = delegate;

 */
public class NormalizingGroovyCompiler implements Compiler<GroovyJavaJointCompileSpec> {
    private static final Logger LOGGER = Logging.getLogger(NormalizingGroovyCompiler.class);
    private final Compiler<GroovyJavaJointCompileSpec> delegate;

    public NormalizingGroovyCompiler(Compiler<GroovyJavaJointCompileSpec> delegate) {
        this.delegate = delegate;