import org.gradle.api.tasks.Nested;

/**
 * Represents a combination of operating system and cpu architecture that a variant might be built for.
 *
 * @since 5.1
 */
public interface TargetMachine {
    /**
     * Returns the target operating system
     */
    @Nested
    OperatingSystemFamily getOperatingSystemFamily();

    /**
     * Returns the target architecture
     */
    @Nested

    }

    public DefaultSwiftPlatform(TargetMachine targetMachine, SwiftVersion sourceCompatibility, NativePlatform nativePlatform) {
        this.targetMachine = targetMachine;
        this.nativePlatform = nativePlatform;
        this.sourceCompatibility = sourceCompatibility;
    }

    @Override
    public TargetMachine getTargetMachine() {
        return targetMachine;
    }

    @Override

import org.gradle.language.cpp.CppPlatform;
import org.gradle.nativeplatform.TargetMachine;
import org.gradle.nativeplatform.platform.NativePlatform;

public class DefaultCppPlatform implements CppPlatform {
    private final TargetMachine targetMachine;
    private final NativePlatform nativePlatform;

    public DefaultCppPlatform(TargetMachine targetMachine) {
        this(targetMachine, null);
    }

/**
 * A builder for configuring the architecture of a {@link TargetMachine} objects.
 *
 * @since 5.2
 */
public interface TargetMachineBuilder extends TargetMachine {
    /**
     * Returns a {@link TargetMachine} for the operating system of this machine and the x86 32-bit architecture
     */
    TargetMachine getX86();

    /**

    private static Set<MachineArchitecture> targetMachinesToArchitectures(Collection<TargetMachine> targetMachines) {
        return targetMachines.stream().map(TargetMachine::getArchitecture).collect(Collectors.toSet());
    }

    private static void addCommonAttributes(BuildType buildType, TargetMachine targetMachine, AttributeContainer runtimeAttributes) {
        runtimeAttributes.attribute(DEBUGGABLE_ATTRIBUTE, buildType.isDebuggable());

        this.name = name;
        this.baseName = baseName;
        this.group = group;
        this.version = version;
        this.debuggable = debuggable;
        this.optimized = optimized;
        this.targetMachine = targetMachine;
        this.linkVariant = linkVariant;

class DefaultToolChainSelectorTest extends Specification {
    def modelRegistry = Stub(ModelRegistry)
    def osFamily = Stub(OperatingSystemFamily)
    def machineArchitecture = Stub(MachineArchitecture)
    def targetMachine = Stub(TargetMachine) {
        getArchitecture() >> machineArchitecture
        getOperatingSystemFamily() >> osFamily
    }
    def os = Stub(OperatingSystemInternal)
    def arch = Stub(ArchitectureInternal)

    }

    @Override
    public NativeToolChainInternal getForPlatform(NativeLanguage sourceLanguage, NativePlatformInternal targetMachine) {
        for (NativeToolChainInternal toolChain : searchOrder) {
            if (toolChain.select(sourceLanguage, targetMachine).isAvailable()) {
                return toolChain;
            }
        }

    public DefaultTargetMachineFactory(ObjectFactory objectFactory) {
        this.objectFactory = objectFactory;
    }

    /**
     * Returns a {@link TargetMachine} representing the operating system and architecture of the current host.
     */
    public TargetMachine host() {
        DefaultNativePlatform host = DefaultNativePlatform.host();

        return Stub(NativeVariantIdentity) {
            getTargetMachine() >> targetMachine(OperatingSystemFamily.WINDOWS, MachineArchitecture.X86_64)
        }
    }

    private TargetMachine targetMachine(String os, String arch) {
        def objectFactory = TestUtil.objectFactory()
        return Stub(TargetMachine) {
            getOperatingSystemFamily() >> objectFactory.named(OperatingSystemFamily.class, os)