}

    List<Variant> getVariants() {
        return variants
    }

    Variant variant(String name) {
        def matches = variants.findAll { it.name == name }
        assert matches.size() == 1 : "Variant '$name' not found in ${variants.name}"
        return matches.first()
    }

    Variant variant(String name, @DelegatesTo(value=Variant, strategy=Closure.DELEGATE_FIRST) Closure<Variant> action) {

[[sec:cpp_library_task_variants]]
=== Variant-dependent Tasks

The {cpp} Library Plugin creates tasks based on variants of the library component.
Read the <<building_cpp_projects.adoc#sec:introducing_build_variants-cpp,introduction to build variants>> for more information.
The following diagrams show the relationship between variant-dependent tasks.

.{cpp} Library Plugin variant-dependent task graph

[[sec:swift_library_task_variants]]
=== Variant-dependent Tasks

The Swift Library Plugin creates tasks based on variants of the library component.
Read the <<building_swift_projects.adoc#sec:introducing_build_variants-swift,introduction to build variants>> for more information.
The following diagrams show the relationship between variant-dependent tasks.

.Swift Library Plugin variant-dependent task graph

     * represents the attributes of the implicit variant. Any further elements of the inner array are explicit
     * sub-variants. The outer array is the collection of all consumable configurations being tested.
     *
     * @param candidates All configurations and their variants being matched against.
     * @param requested The requested attributes.
     *
     * @return The single matched variant.
     *

        def variant = variants.find { it.name == name }
        if (variant == null) {
            variant = createVariant(name, [:])
        }
        action.resolveStrategy = Closure.DELEGATE_FIRST
        action.delegate = variant
        action()
        return this
    }

    @Override
    IvyModule withoutDefaultVariants() {
        variants.clear()
        return this
    }

        then:
        javaLibrary.parsedModuleMetadata.variant("apiElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("runtimeElements") {
            noMoreDependencies()
        }
        !javaLibrary.parsedModuleMetadata.variants.name.contains('optionalFeatureRuntimeElements')
        javaLibrary.parsedModuleMetadata.variant("optionalFeatureRuntimeElementsAlternate") {

        then:
        javaLibrary.parsedModuleMetadata.variant("apiElements") {
            noMoreDependencies()
        }
        javaLibrary.parsedModuleMetadata.variant("runtimeElements") {
            noMoreDependencies()
        }
        !javaLibrary.parsedModuleMetadata.variants.name.contains('optionalFeatureRuntimeElements')
        javaLibrary.parsedModuleMetadata.variant("optionalFeatureRuntimeElementsAlternate") {

        println "components: " + artifacts.collect { it.id.componentIdentifier }
        println "variants: " + artifacts.collect { it.variant.attributes }
    }
}
"""
        when:
        succeeds "resolve"

        then:
        output.contains('variants: [{artifactType=size, org.gradle.dependency.bundling=external, org.gradle.libraryelements=jar, org.gradle.usage=java-api}]')

            DefaultIvyDependencySet ivyDependencies = instantiator.newInstance(DefaultIvyDependencySet.class, collectionCallbackActionDecorator);
            Map<String, VariantWarningCollector> warnings = new HashMap<>();

            for (ParsedVariantDependencyResult variant : variants) {
                ivyDependencies.addAll(variant.dependencies);
                warnings.put(variant.name, variant.warnings);

            return variants;
        }
        ImmutableList.Builder<ComponentVariant> builder = new ImmutableList.Builder<>();
        if (variants != null) {
            builder.addAll(variants);
        }
        for (MutableComponentVariant variant : newVariants) {