private List<? extends LaunchableGradleTaskSelector> selectors;
    private List<? extends LaunchableGradleTask> tasks;
    private DefaultProjectIdentifier projectIdentifier;

    public DefaultBuildInvocations setSelectors(List<? extends LaunchableGradleTaskSelector> selectors) {
        this.selectors = selectors;
        return this;
    }

    public List<? extends LaunchableGradleTaskSelector> getTaskSelectors() {

        List<LaunchableGradleTask> projectTasks = tasks(project, projectIdentifier);

        // construct build invocations from task selectors and project tasks
        return new DefaultBuildInvocations()
            .setSelectors(selectors)
            .setTasks(projectTasks)
            .setProjectIdentifier(projectIdentifier);
    }

    private DefaultProjectIdentifier getProjectIdentifier(Project project) {

     */
    public void restartIncomingEdges(ComponentState selected) {
        for (NodeState node : nodes) {
            node.restart(selected);
        }
    }

    public void setSelectors(ModuleSelectors<SelectorState> selectors) {
        this.selectors = selectors;
    }

    /**
     * Returns true if this module version can be resolved quickly (already resolved or local)
     *

            // Selection deferred as we know another selector will be added soon
            return;
        }
        ComponentState newSelected = selectorStateResolver.selectBest(getId(), selectors);
        newSelected.setSelectors(selectors);
        if (selected == null) {
            // In some cases we should ignore this because the selection happens to be a known conflict
            if (!conflictTracker.hasKnownConflict(newSelected.getId())) {

			svctest.SetSelector(map[string]string{})),
		expect: svctest.MakeService("foo", svctest.SetHeadless,
			svctest.SetIPFamilyPolicy(api.IPFamilyPolicyRequireDualStack),
			svctest.SetIPFamilies(api.IPv4Protocol, api.IPv6Protocol)),
	}, {
		name: "headless selectorless pre-set",
		input: svctest.MakeService("foo", svctest.SetHeadless,
			svctest.SetSelector(map[string]string{}),

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

import java.util.List;

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

}

// SetHeadless sets the service as headless and clears other fields.
func SetHeadless(svc *api.Service) {
	SetTypeClusterIP(svc)
	SetClusterIPs(api.ClusterIPNone)(svc)
}

// SetSelector sets the service selector.
func SetSelector(sel map[string]string) Tweak {
	return func(svc *api.Service) {
		svc.Spec.Selector = map[string]string{}
		for k, v := range sel {
			svc.Spec.Selector[k] = v
		}
	}
}

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