*/
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() {

        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) {

    }

    @Override
    public String getGroup() {
        return group;
    }

    @Override
    public boolean excludes(ModuleIdentifier module) {
        return group.equals(module.getGroup());
    }

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

    @Override
    public boolean mayExcludeArtifacts() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.notations;

import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.internal.artifacts.ImmutableModuleIdentifierFactory;
import org.gradle.internal.exceptions.DiagnosticsVisitor;
import org.gradle.internal.typeconversion.NotationConvertResult;

            return null;
        }

        return ResolvedCoordinates.create(group, name, resolvedVersion);
    }

    private static Map<ModuleIdentifier, String> getResolvedComponentVersions(ResolvedComponentResult root) {
        Map<ModuleIdentifier, String> resolvedComponentVersions = new HashMap<>();

        eachElement(root, (Action<? super ResolvedComponentResult>) component -> {