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 DependencySubstitutionApplicator {
    SubstitutionResult NO_OP_SUBSTITUTION_RESULT = SubstitutionResult.of(NoOpSubstitution.INSTANCE);
    DependencySubstitutionApplicator NO_OP = dependency -> NO_OP_SUBSTITUTION_RESULT;

    SubstitutionResult apply(DependencyMetadata dependency);

    class SubstitutionResult {
        private final DependencySubstitutionInternal result;

 */
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.

import org.gradle.api.tasks.diagnostics.internal.graph.nodes.RenderableDependency;
import org.gradle.internal.logging.text.StyledTextOutput;

public interface NodeRenderer {
    NodeRenderer NO_OP = (output, node, alreadyRendered) -> {
    };

    void renderNode(StyledTextOutput output, RenderableDependency node, boolean alreadyRendered);

 */

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 {

            Set<ImmutableAttributes> candidates = attributeBasedMappings.keySet();
            List<ImmutableAttributes> matches = matcher.matches(candidates, variantAttributes, AttributeMatchingExplanationBuilder.NO_OP);
            if (matches.size() == 1) {
                Collection<Action<? super VariantVersionMappingStrategy>> actions = attributeBasedMappings.get(matches.get(0));

import org.gradle.api.artifacts.ComponentMetadata;
import org.gradle.internal.component.external.model.ModuleComponentResolveMetadata;

public interface ComponentMetadataProcessor {
    ComponentMetadataProcessor NO_OP = new ComponentMetadataProcessor() {
        @Override
        public ModuleComponentResolveMetadata processMetadata(ModuleComponentResolveMetadata metadata) {
            return metadata;
        }

        @Override