}

    public DefaultDependencyConstraint(ModuleIdentifier module, VersionConstraint versionConstraint) {
        this(module, new DefaultMutableVersionConstraint(versionConstraint));
    }

    private DefaultDependencyConstraint(ModuleIdentifier module, MutableVersionConstraint versionConstraint) {
        this.moduleIdentifier = module;
        this.versionConstraint = versionConstraint;
    }

        private final Set<ModuleIdentifier> participants;

        private HasConflict(Set<ModuleIdentifier> participants) {
            this.participants = participants;
        }

        @Override
        public void withParticipatingModules(Action<ModuleIdentifier> action) {
            for (ModuleIdentifier participant : participants) {
                action.execute(participant);

    }

    private static PluginRequestInternal createDevelocityPluginRequest() {
        ModuleIdentifier moduleIdentifier = DefaultModuleIdentifier.newId(AutoAppliedDevelocityPlugin.GROUP, AutoAppliedDevelocityPlugin.NAME);
        ModuleVersionSelector artifact = DefaultModuleVersionSelector.newSelector(moduleIdentifier, AutoAppliedDevelocityPlugin.VERSION);
        return new DefaultPluginRequest(

            return false;
        }
    };

    @Nullable Replacement getReplacementFor(ModuleIdentifier sourceModule);

    boolean participatesInReplacements(ModuleIdentifier moduleId);

    class Replacement {
        private final ModuleIdentifier target;
        private final String reason;

        Replacement(ModuleIdentifier target, @Nullable String reason) {

        private final ModuleIdentifier moduleIdentifier;
        private final ModuleComponentIdentifier moduleComponentIdentifier;
        private boolean notFound;

        private DefaultArtifactResolutionDetails(ModuleIdentifier moduleIdentifier, @Nullable ModuleComponentIdentifier componentId) {
            this.moduleIdentifier = moduleIdentifier;
            this.moduleComponentIdentifier = componentId;

        }
        LOGGER.debug("Selected {} from conflicting modules {}.", selected, conflict.candidates);
    }

    private void maybeSetReason(Set<ModuleIdentifier> partifipants, ComponentResolutionState selected) {
        for (ModuleIdentifier identifier : partifipants) {
            ModuleReplacementsData.Replacement replacement = moduleReplacements.getReplacementFor(identifier);
            if (replacement != null) {

    ModuleExclude module(String module);

    ModuleIdExclude moduleId(ModuleIdentifier id);

    ExcludeSpec anyOf(ExcludeSpec one, ExcludeSpec two);

    ExcludeSpec allOf(ExcludeSpec one, ExcludeSpec two);

    ExcludeSpec anyOf(Set<ExcludeSpec> specs);

    ExcludeSpec allOf(Set<ExcludeSpec> specs);

    ExcludeSpec ivyPatternExclude(ModuleIdentifier moduleId, IvyArtifactName artifact, String matcher);

 */
package org.gradle.api.internal.artifacts;

import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.artifacts.ModuleVersionIdentifier;
import org.gradle.internal.service.scopes.Scope.Global;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Global.class)
public interface ImmutableModuleIdentifierFactory {
    ModuleIdentifier module(String group, String name);

            return new DefaultVcsMappingFactory(objectFactory, versionControlSpecFactory);
        }

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

        ModuleIdentifier module = owner.getModuleVersion().getModule();
        return new Conflict(ImmutableList.copyOf(owner.getAllVersions()), buildConflictMessage(module, selectionReason));
    }

    private static String buildConflictMessage(ModuleIdentifier owner, ComponentSelectionReason selectionReason) {
        String conflictDescription = null;