* limitations under the License.
 */
package org.gradle.api.artifacts.component;

import org.gradle.internal.HasInternalProtocol;
import org.gradle.internal.scan.UsedByScanPlugin;

/**
 * Criteria for selecting a component instance that is built as part of the current build.
 *
 * @since 1.10
 */
@UsedByScanPlugin
@HasInternalProtocol
public interface ProjectComponentSelector extends ComponentSelector {
    /**

package org.gradle.api.artifacts.component;

import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.artifacts.VersionConstraint;
import org.gradle.internal.scan.UsedByScanPlugin;

/**
 * Criteria for selecting a component instance that is available as a module version.
 *
 * @since 1.10
 */
@UsedByScanPlugin
public interface ModuleComponentSelector extends ComponentSelector {
    /**

import java.util.List;

/**
 * A {@link ResolutionFailure} that represents the situation when multiple incompatible variants of a single component
 * are selecting during a request.
 */
public final class IncompatibleMultipleNodeSelectionFailure extends AbstractVariantSelectionFailure {
    private final ImmutableList<AssessedCandidate> assessedCandidates;

Then, users _have to_ express their preferences, if possible, or fix the problem of having incompatible things on the classpath, as explained in the following section.
====

[[sub:selecting-between-candidates]]
== Selecting between candidates

At some point, a dependency graph is going to include either _incompatible modules_, or modules which are _mutually exclusive_.

            return 0;
        };
    };

    ModuleComponentResolveMetadata processMetadata(ModuleComponentResolveMetadata metadata);

    /**
     * Processes "shallow" metadata, only for selecting a version. This metadata is typically
     * provided by a custom metadata processor.
     * @param metadata the metadata to be processed
     * @return updated metadata, if any component metadata rule applies.
     */

    /**
     * Selects a response producer to handle the given request.
     *
     * This method is called under the state lock. The handler is _not_ called under the state lock. That is, the lock is held only while selecting how to handle the request.
     *
     * This method may block until the request is ready to be handled, but must do so using a condition created from the state lock.
     *

                            implies that the Selector is limited to selecting only
                            workload endpoints in the same namespace as the NetworkPolicy.
                            \n For NetworkPolicy, `global()` NamespaceSelector implies
                            that the Selector is limited to selecting only GlobalNetworkSet
                            or HostEndpoint. \n For GlobalNetworkPolicy, an empty

  content: |
    The logic to determine if a pod requires sideacr injection or not has been updated to make use of
    new Kubernetes features. Previously, the webhook was triggered at a coarse grain level, selecting any
    pods in a namespace with a matching `istio-injection=enabled` label.

    This has two limitations:

    * Opting out individual pods with the `sidecar.istio.io/inject` label would still trigger the webhook,

 * limitations under the License.
 */

package org.gradle.api.artifacts.component;

import javax.annotation.Nullable;

/**
 * Criteria for selecting a library instance that is built as part of the current build.
 */
public interface LibraryComponentSelector extends ComponentSelector {
    /**
     * Return the project path of the selected library.
     *

  // stash these in static fields to avoid loading them over and over again (speeds up test
  // execution significantly)

  /**
   * This classloader disallows {@link sun.misc.Unsafe}, which will prevent us from selecting our
   * preferred strategy {@code UnsafeAtomicHelper}.
   */
  @SuppressWarnings({"SunApi", "removal"}) // b/345822163
  private static final ClassLoader NO_UNSAFE =