// Intersect intersects Audiences with a target Audiences and returns all
// elements in both.
func (a Audiences) Intersect(tauds Audiences) Audiences {
	selected := Audiences{}
	for _, taud := range tauds {
		if a.Has(taud) {
			selected = append(selected, taud)
		}
	}
	return selected

 *
 * <p>Defines a fixed set of criteria that a model node must match. A node is only selected when it matches all non-null criteria.</p>
 */
public abstract class ModelPredicate {
    /**
     * Returns the path of the node to select, or null if path is not relevant.
     *
     * <p>A node will be selected if its path equals the specified path.
     */
    @Nullable
    public ModelPath getPath() {

    }

    public static <T> Spec<T> convertClosureToSpec(final Closure<?> closure) {
        return new ClosureSpec<>(closure);
    }

    /**
     * Returns a spec that selects the intersection of those items selected by the given specs. Returns a spec that selects everything when no specs provided.
     */
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> Spec<T> intersect(Spec<? super T>... specs) {

    }

    private boolean matchesSelected(ResolvedDependencyResult candidate) {
        ComponentIdentifier selected = candidate.getSelected().getId();

        if (selected instanceof ModuleComponentIdentifier) {
            ModuleComponentIdentifier selectedModule = (ModuleComponentIdentifier) selected;
            return selectedModule.getGroup().equals(moduleIdentifier.getGroup())

	}

	// Pick 2 endpoints at random.
	c1, c2 := lb.pick2()

	// Choose the endpoint with fewer active requests.
	selected := c1
	if c2.ActiveRequests() < c1.ActiveRequests() {
		selected = c2
	}

	// Apply the selected endpoint to the metrics decorator and send the request.
	lb.doRequest(selected, onDone)
}

type weightedLeastRequest struct {
	*weightedConnections
	activeRequestBias float64
	edf               *EDF

            ComponentState selected = module.getSelected();
            if (selected != null) {
                ResolutionFailureHandler resolutionFailureHandler = resolveState.getVariantSelector().getFailureHandler();
                if (selected.isRejected()) {
                    GradleException error = new GradleException(selected.getRejectedErrorMessage());

    }

    def "creates wrapper for non-empty set of selected artifacts"() {
        def target = Stub(ArtifactSet)
        def selector = Stub(ArtifactVariantSelector)
        def selected = Stub(ResolvedArtifactSet)
        def visitor = Mock(TaskDependencyResolveContext)

        given:
        target.select(_, _) >> selected

        when:

        when:
        resolveConflicts()

        then:
        selected '1.1'
    }

    def "can select a release version over unqualified"() {
        given:
        prefer('1.0-beta-1').release()
        prefer('1.0-beta-2')

        when:
        resolveConflicts()

        then:
        selected '1.0-beta-1'
    }

    def "can select qualified release over unqualified"() {

     *
     * @return this details instance
     */
    CapabilityResolutionDetails selectHighestVersion();

    /**
     * Describes why a particular candidate is selected.
     *
     * @param reason the reason why a candidate is selected.
     *
     * @return this details instance
     */
    CapabilityResolutionDetails because(String reason);

plugins {
    java
}

// tag::ignore-property-selected[]
normalization {
    runtimeClasspath {
        properties("**/build-info.properties") {
            ignoreProperty("timestamp")
        }
    }
}
// end::ignore-property-selected[]

// tag::ignore-property-all[]
normalization {
    runtimeClasspath {
        properties {
            ignoreProperty("timestamp")
        }
    }
}