*/
    void architecture(String name);

    /**
     * The operating system being targeted.
     * Defaults to the default operating system targeted by the tool chain (normally the current operating system).
     */
    @Nested
    OperatingSystem getOperatingSystem();

    /**
     * Sets the operating system being targeted.
     * <p>

        rules.withModule("group:module") { }

        then:
        e = thrown(InvalidUserCodeException)
        e.message == "bad targeted closure"

        and:
        1 * adapter.createFromClosure(ComponentSelection, _) >> { throw new InvalidUserCodeException("bad targeted closure") }
    }

    def "propagates error creating rule for rule source" () {
        when:
        rules.all ruleSource

 */
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 {