import org.gradle.api.Action;
import org.gradle.api.artifacts.ModuleIdentifier;

class DeselectVersionAction implements Action<ModuleIdentifier> {
    private final ResolveState resolveState;

    DeselectVersionAction(ResolveState resolveState) {
        this.resolveState = resolveState;
    }

    @Override
    public void execute(ModuleIdentifier module) {
        resolveState.getModule(module).clearSelection();
    }

        return INSTANCE;
    }

    private DefaultExcludeNothing() {
    }

    @Override
    public boolean excludes(ModuleIdentifier module) {
        return false;
    }

    @Override
    public boolean excludesArtifact(ModuleIdentifier module, IvyArtifactName artifactName) {
        return false;
    }

    @Override
    public boolean mayExcludeArtifacts() {
        return false;

 */
package org.gradle.api.internal.artifacts.ivyservice.modulecache.dynamicversions;

import org.gradle.api.artifacts.ModuleIdentifier;

class ModuleAtRepositoryKey {
    final String repositoryId;
    final ModuleIdentifier moduleId;

    ModuleAtRepositoryKey(String repositoryId, ModuleIdentifier moduleId) {
        this.repositoryId = repositoryId;
        this.moduleId = moduleId;
    }

    @Override

package org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs;

import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.internal.component.model.IvyArtifactName;

public interface ExcludeSpec {
    /**
     * Determines if this exclude rule excludes the supplied module.
     */
    boolean excludes(ModuleIdentifier module);

    /**

            return new DefaultVcsMappingFactory(objectFactory, versionControlSpecFactory);
        }

        @Provides
        VersionControlSpecFactory createVersionControlSpecFactory(ObjectFactory objectFactory, NotationParser<String, ModuleIdentifier> notationParser) {

    }

    @Override
    public Set<String> getGroups() {
        return groups;
    }

    @Override
    public boolean excludes(ModuleIdentifier module) {
        return groups.contains(module.getGroup());
    }

    @Override
    public boolean excludesArtifact(ModuleIdentifier module, IvyArtifactName artifactName) {
        return false;
    }

    @Override
    public boolean mayExcludeArtifacts() {

        private List<ClassLoader> additionalClassloaders;

        static class ModuleReplacement {
            private final ModuleIdentifier original;
            private final ModuleIdentifier replacement;

            public ModuleReplacement(ModuleIdentifier original, ModuleIdentifier replacement) {
                this.original = original;
                this.replacement = replacement;
            }
        }

        return attributes;
    }

    @Override
    public boolean isComplete(ModuleIdentifier moduleIdentifier) {
        return isValidSubstitute(moduleIdentifier.getName(), false)
            && isValidSubstitute(moduleIdentifier.getGroup(), organisationIsOptional);
    }

    @Override
    public boolean isComplete(ModuleComponentIdentifier componentIdentifier) {

        return delegate.allOf(specs);
    }

    @Override
    public ExcludeSpec ivyPatternExclude(ModuleIdentifier moduleId, IvyArtifactName artifact, String matcher) {
        return delegate.ivyPatternExclude(moduleId, artifact, matcher);
    }

    @Override
    public ModuleIdSetExclude moduleIdSet(Set<ModuleIdentifier> modules) {
        return delegate.moduleIdSet(modules);
    }

    @Override

        return "any of";
    }

    @Override
    public boolean excludes(ModuleIdentifier module) {
        for (ExcludeSpec component : getComponents()) {
            if (component.excludes(module)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean excludesArtifact(ModuleIdentifier module, IvyArtifactName artifactName) {