private final ObjectFactory objectFactory;
    private final NotationParser<String, ModuleIdentifier> notationParser;

    public DefaultVersionControlSpecFactory(ObjectFactory objectFactory, NotationParser<String, ModuleIdentifier> notationParser) {
        this.objectFactory = objectFactory;
        this.notationParser = notationParser;
    }

    @Override

        return "all of";
    }

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

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

 */
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 ArtifactExclude extends ExcludeSpec {
    @Override
    default boolean excludes(ModuleIdentifier module) {
        return false;
    }

    @Override
    default boolean mayExcludeArtifacts() {
        return true;

        return INSTANCE;
    }

    private DefaultExcludeEverything() {
    }

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

    @Override
    public boolean excludesArtifact(ModuleIdentifier module, IvyArtifactName artifactName) {
        // everything excluded **only** applies to modules, not artifacts!
        return false;
    }

    @Override

 * that substitutes a project within the composite with any dependency with a matching ModuleIdentifier.
 */
public class CompositeBuildDependencySubstitutions implements Action<DependencySubstitution> {
    private static final Logger LOGGER = LoggerFactory.getLogger(CompositeBuildDependencySubstitutions.class);

    private final Multimap<ModuleIdentifier, ProjectComponentIdentifier> replacementMap = ArrayListMultimap.create();

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal.artifacts;

import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.artifacts.ModuleVersionSelector;
import org.gradle.api.artifacts.component.ComponentSelector;

/**
 * Adapts the new `ComponentSelector` types to legacy types.

    }

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

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

    @Override

    }

    @Override
    public Set<String> getModules() {
        return modules;
    }

    @Override
    public boolean excludes(ModuleIdentifier module) {
        return modules.contains(module.getName());
    }

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

    @Override
    public boolean mayExcludeArtifacts() {

    }

    @Override
    public ExternalResourceName toVersionListPattern(ModuleIdentifier module, IvyArtifactName artifact) {
        Map<String, String> attributes = toAttributes(module, artifact);
        return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

    @Override
    public ExternalResourceName toModulePath(ModuleIdentifier module) {
        String pattern = getBase().getPath();

            return conflictedNodes;
        }

        @Override
        public void withParticipatingModules(Action<? super ModuleIdentifier> action) {
            Set<ModuleIdentifier> seen = new HashSet<>();
            for (NodeState node : conflict.nodes) {
                ModuleIdentifier module = node.getComponent().getId().getModule();
                if (seen.add(module)) {
                    action.execute(module);