*/
public interface PlatformAwareComponentSpecInternal extends PlatformAwareComponentSpec, HasIntermediateOutputsComponentSpec {
    /**
     * Get the names of the targeted platforms that this component should be built for.
     *
     * @return the list of targeted platforms, may be empty but never null.
     */
    List<PlatformRequirement> getTargetPlatforms();

        DependencyMetadata targeted = dependency.withTarget(target);
        return new DependencyState(targeted, requested, ruleDescriptors, componentSelectorConverter);
    }


    public DependencyState withTargetAndArtifacts(ComponentSelector target, List<DependencyArtifactSelector> targetSelectors, List<ComponentSelectionDescriptorInternal> ruleDescriptors) {

tasks.register('printMetadataRulesConfig') {
    FileCollection metadataRulesConfig = configurations.metadataRulesConfig
    doLast {
        metadataRulesConfig.each { println "Resolved: ${it.name}" }
    }
}

// tag::targeted-component-selection[]
configurations {
    targetConfig {
        resolutionStrategy {
            componentSelection {
                withModule("org.sample:api") { ComponentSelection selection ->

tasks.register("printMetadataRulesConfig") {
    val metadataRulesConfig: FileCollection = configurations["metadataRulesConfig"]
    doLast {
        metadataRulesConfig.forEach { println("Resolved: ${it.name}") }
    }
}

// tag::targeted-component-selection[]
configurations {
    create("targetConfig") {
        resolutionStrategy {
            componentSelection {
                withModule("org.sample:api") {

	// unless it is chained, but we will handle this case later.
	targetOff := add + unwStaticDataSize + unwCodeSize*int64(codes)
	xrels := ldr.Relocs(xsym)
	xrelsCount := xrels.Count()
	idx := sort.Search(xrelsCount, func(i int) bool {
		return int64(xrels.At(i).Off()) >= targetOff
	})
	if idx == xrelsCount {
		return 0
	}
	if isChained {

 * limitations under the License.
 */
package org.gradle.nativeplatform;

import org.gradle.api.Incubating;

import java.io.File;

/**
 * A binary artifact for a {@link NativeExecutable}, targeted at a particular platform with specific configuration.
 */
@Incubating
public interface NativeExecutableBinary extends NativeBinary {
    /**
     * The executable file.
     */
    File getExecutableFile();

     * The {@link org.gradle.nativeplatform.Flavor} that this binary was built with.
     */
    Flavor getFlavor();

    /**
     * Returns the {@link org.gradle.nativeplatform.platform.NativePlatform} that this binary is targeted to run on.
     */
    NativePlatform getTargetPlatform();

    /**
     * Returns the {@link org.gradle.nativeplatform.BuildType} used to construct this binary.
     */
    BuildType getBuildType();

	stats, ok := list.targetStats[id]
	if !ok {
		stats = targetStat{}
	}

	stats.totalEvents++
	list.targetStats[id] = stats
	return
}

type asyncEvent struct {
	ev        Event
	targetSet TargetIDSet
}

// Add - adds unique target to target list.
func (list *TargetList) Add(targets ...Target) error {
	list.Lock()
	defer list.Unlock()

	for _, target := range targets {

// and the object and new field name are returned.
//
// The intended use for RenameResult is to allow rangefunc to assign results within a closure.
// This is a hack, as narrowly targeted as possible to discourage abuse.
func (s *Signature) RenameResult(results []*syntax.Field, i int) (*Var, *syntax.Name) {
	a := results[i]
	obj := s.Results().At(i)

To influence the generic suggestions Gradle displays, the NonGradleCause interface was introduced.
If an exception implements this interface, Gradle will not display the `--stacktrace` option.

Another more targeted interface is `CompilationFailedIndicator`.
This interface is used to indicate that the exception is caused by a compilation failure.