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.

	handleResource := func(r *resource.Instance, gvkType config.GroupVersionKind) {
		spec, ok := r.Message.(policy)
		if spec.GetTargetRef() != nil {
			return
		}
		if !ok || spec.GetSelector() == nil {
			return
		}
		selector := spec.GetSelector()
		for _, pod := range pods[r.Metadata.FullName.Namespace.String()] {
			if maps.Contains(pod, selector.MatchLabels) {

	apNs := r.Metadata.FullName.Namespace.String()

	// If AuthzPolicy is mesh-wide
	if meshWidePolicy(apNs, c) {
		// If it has selector, need further analysis
		if ap.GetSelector() != nil {
			apSelector := klabels.SelectorFromSet(ap.GetSelector().MatchLabels)
			// If there is at least one pod matching the selector within the whole mesh
			if !hasMatchingPodsRunning(apSelector, podLabelsMap) {

        incomingEdges.addAll(module.getUnattachedDependencies());
        for (EdgeState incomingEdge : incomingEdges) {
            SelectorState selector = incomingEdge.getSelector();
            for (String path : pathTo(incomingEdge, false)) {
                String requestedAttribute = formatAttributeQuery(selector, attribute);
                fmt.node(path + " " + requestedAttribute);
            }

        this.versionSelector = versionSelector;
    }

    public VersionSelector getInverseSelector() {
        return versionSelector;
    }

    @Override
    public String getSelector() {
        return "!(" + versionSelector.getSelector() + ")";
    }

    @Override
    public boolean isDynamic() {
        return versionSelector.isDynamic();
    }

    @Override
    public boolean requiresMetadata() {