return null;
    }

    private ExcludeSpec tryGroupUnion(GroupExclude left, ExcludeSpec right) {
        String leftGroup = left.getGroup();
        if (right instanceof ModuleIdExclude) {
            ModuleIdExclude mie = (ModuleIdExclude) right;
            if (mie.getModuleId().getGroup().equals(leftGroup)) {
                return left;
            }
        }
        if (right instanceof ModuleIdSetExclude) {

        ModuleVersionIdentifier resolved = maybeResolveVersion(coordinates.getGroup(), coordinates.getName(), identityPath);
        return ResolvedCoordinates.create(resolved != null ? resolved : coordinates);
    }

    @Nullable
    @Override
    public ResolvedCoordinates resolveComponentCoordinates(DependencyConstraint dependency) {
        return resolveModule(dependency.getGroup(), dependency.getName());
    }

    @Override

    public boolean matchesStrictly(ModuleVersionIdentifier identifier) {
        return new ModuleVersionSelectorStrictSpec(this).isSatisfiedBy(identifier);
    }

    @Override
    public String getGroup() {
        return moduleIdentifier.getGroup();
    }

    @Override
    public String getName() {
        return moduleIdentifier.getName();
    }

    @Override
    public String getVersion() {

        this.artifactKind = artifactKind;
        this.file = file;
    }

    public ModuleComponentArtifactIdentifier getId() {
        return id;
    }

    String getGroup() {
        return id.getComponentIdentifier().getGroup();
    }

    String getModule() {
        return id.getComponentIdentifier().getModule();
    }

    String getVersion() {
        return id.getComponentIdentifier().getVersion();

                            groupByModuleId(e, moduleIds);
                        } else {
                            List<String> groups = moduleIds.stream()
                                .map(ModuleIdentifier::getGroup)
                                .distinct()
                                .collect(Collectors.toList());
                            if (groups.size() == 1) {
                                groupByGroupOnly(e, groups);

    public static DefaultImmutableCapability defaultCapabilityForComponent(ModuleVersionIdentifier identifier) {
        return new DefaultImmutableCapability(identifier.getGroup(), identifier.getName(), identifier.getVersion());
    }

    private final String group;
    private final String name;
    private final String version;
    private final int hashCode;

    }

    public ModuleVersionResolveException(ModuleComponentIdentifier id, Factory<String> messageFormat, Throwable cause) {

    }

    protected void updateMetadata(ModuleDependencyMetadata modifiedMetadata) {
        this.metadata = modifiedMetadata;
    }

    @Override
    public String getGroup() {
        return getMetadata().getSelector().getGroup();
    }

    @Override
    public String getName() {
        return getMetadata().getSelector().getModule();
    }

    @Override

                projectDependency.getVersion(),
                "",
                Collections.emptyList(),
                ""
        );
    }

    @Override
    public String getGroup() {
        return projectDependency.getGroup();
    }

    @Override
    public String getName() {
        return projectDependency.getName();
    }

    @Nullable
    @Override
    public String getVersion() {

    static GroupExclude of(String group) {
        return new DefaultGroupExclude(group);
    }

    @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;