}
        if (subscriptions.isRequested(OperationType.GENERIC)) {
            return new ClientForwardingBuildOperationListener(progressEventConsumer);
        }
        return NO_OP;
    }

    @Nonnull
    private ProblemsProgressEventConsumer createProblemsProgressConsumer(ProgressEventConsumer progressEventConsumer) {

import org.gradle.internal.state.ModelObject;

import javax.annotation.Nullable;

@ServiceScope({Scope.Global.class, Scope.Project.class})
public interface PropertyHost {
    PropertyHost NO_OP = producer -> null;

    /**
     * Returns null if the host allows reads of its state, or a string that explains why reads are not allowed.
     */
    @Nullable
    String beforeRead(@Nullable ModelObject producer);

import javax.inject.Inject;
import java.util.List;

import static org.gradle.api.internal.artifacts.ivyservice.dependencysubstitution.DependencySubstitutionApplicator.NO_OP;

/**
 * Resolves a dependency graph and visits it. Essentially, this class is a {@link DependencyGraphBuilder} executor.
 */
public class DependencyGraphResolver {

@ServiceScope(Scope.BuildTree.class)
public interface VcsMappingsStore {
    VcsResolver asResolver();

    void addRule(Action<? super VcsMapping> rule, Gradle gradle);

    VcsResolver NO_OP = new VcsResolver() {
        @Nullable
        @Override
        public VersionControlSpec locateVcsFor(ModuleComponentSelector selector) {
            return null;
        }

        @Override

package org.gradle.internal.problems.failure;

/**
 * Listener for steps in the process of printing a failure by {@link FailurePrinter}.
 */
public interface FailurePrinterListener {

    FailurePrinterListener NO_OP = new FailurePrinterListener() {
        @Override
        public void beforeFrames() {}

        @Override
        public void beforeFrame(StackTraceElement element, StackTraceRelevance relevance) {}

 */
public interface CacheCleanupStrategy {
    CacheCleanupStrategy NO_CLEANUP = new CacheCleanupStrategy() {
        @Override
        public CleanupAction getCleanupAction() {
            return CleanupAction.NO_OP;
        }

        @Override
        public CleanupFrequency getCleanupFrequency() {
            return CleanupFrequency.NEVER;
        }
    };

    /**
     * Returns the action to perform on cleanup.

 */

package org.gradle.api.internal.artifacts.dsl;

import org.gradle.api.artifacts.ModuleIdentifier;

import javax.annotation.Nullable;

public interface ModuleReplacementsData {
    ModuleReplacementsData NO_OP = new ModuleReplacementsData() {
        @Nullable
        @Override
        public Replacement getReplacementFor(ModuleIdentifier sourceModule) {
            return null;
        }

        @Override

            initializer.accept(cache);
        }
        return cache;
    }

    public PersistentCache open(File cacheDir, String displayName) {
        return new InMemoryCache(cacheDir, displayName, CleanupAction.NO_OP);
    }

    @Override
    public void visitCaches(CacheVisitor visitor) {
        throw new UnsupportedOperationException();
    }

    private class InMemoryCache implements PersistentCache {

import org.gradle.util.Path;

import java.util.function.Supplier;

@ServiceScope(Scope.BuildTree.class)
public interface ProjectScopedScriptResolution {
    ProjectScopedScriptResolution NO_OP = new ProjectScopedScriptResolution() {
        @Override
        public <T> T resolveScriptsForProject(Path identityPath, Supplier<T> action) {
            return action.get();
        }
    };

                ? this.executionListenerFactory
                : () -> DefaultBuildOperationRunner.BuildOperationExecutionListener.NO_OP;

            return new DefaultBuildOperationRunner(
                CurrentBuildOperationRef.instance(),
                timeSupplier,
                new DefaultBuildOperationIdFactory(),