*/
package org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy;

import java.util.List;

public interface CompositeVersionSelector extends VersionSelector {
    List<VersionSelector> getSelectors();

            }
        }
        return true;
    }

    @Override
    public String getSelector() {
        throw new UnsupportedOperationException("Union selectors should only be used internally and don't provide a public string representation");
    }

    @Override
    public List<VersionSelector> getSelectors() {
        return selectors;
    }

import java.util.Set;

class RejectedModuleMessageBuilder {
    String buildFailureMessage(ModuleResolveState module) {
        boolean hasRejectAll = false;
        for (SelectorState candidate : module.getSelectors()) {
            ResolvedVersionConstraint versionConstraint = candidate.getVersionConstraint();
            if (versionConstraint != null) {
                hasRejectAll |= versionConstraint.isRejectAll();
            }

        }
    }

    @Nullable
    private String getForcedVersion() {
        String version = null;
        for (SelectorState selector : platformModule.getSelectors()) {
            if (selector.hasStrongOpinion()) {
                ComponentSelector requested = selector.getRequested();
                if (requested instanceof ModuleComponentSelector) {

    abstract VersionSelector getSelector(String selector);

    def accept(String s1, String s2) {
        return getSelector(s1).accept(s2)
    }

    def accept(String s1, ComponentMetadata cmd) {
        return getSelector(s1).accept(cmd)
    }

    def isDynamic(String s1) {
        return getSelector(s1).isDynamic()
    }

    def requiresMetadata(String s1) {

    }

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

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

    @Override
    public VersionConstraint getVersionConstraint() {
        return getMetadata().getSelector().getVersionConstraint();
    }

    @Override

    @Override
    public void resolve(DependencyMetadata dependency, VersionSelector acceptor, @Nullable VersionSelector rejector, BuildableComponentIdResolveResult result) {
        ComponentSelector componentSelector = dependency.getSelector();
        if (componentSelector instanceof ModuleComponentSelector) {
            ModuleComponentSelector module = (ModuleComponentSelector) componentSelector;
            if (acceptor.isDynamic()) {

    protected abstract ModuleDependencyMetadata withRequestedAndArtifacts(ModuleComponentSelector newSelector, List<IvyArtifactName> artifacts);

    @Override
    public ModuleComponentSelector getSelector() {
        return getDependencyDescriptor().getSelector();
    }

    @Override
    public boolean isChanging() {
        return getDependencyDescriptor().isChanging();
    }

    @Override

        }
        return this;
    }

    @Override
    public ModuleComponentSelector getSelector() {
        return (ModuleComponentSelector) delegate.getSelector();
    }

func (p *ProxyConfigs) mergedWorkloadConfig(namespace string, l map[string]string) *meshconfig.ProxyConfig {
	for _, pc := range p.namespaceToProxyConfigs[namespace] {
		if len(pc.GetSelector().GetMatchLabels()) == 0 {
			continue
		}
		selector := labels.Instance(pc.GetSelector().GetMatchLabels())
		if selector.SubsetOf(l) {
			// return the first match. this is consistent since
			// we sort the resources by creation time beforehand.