mainVariantImplementation[label=<main<i>Variant</i>Implementation>]
  }

  subgraph left {
    node[style=filled, fillcolor="#cfe2f3"]
    cppCompileVariant -> nativeLinkVariant -> nativeRuntimeVariant [style=invis, weight=1000]

    cppCompileVariant[label=<cppCompile<i>Variant</i> (R)>]
    nativeLinkVariant[label=<nativeLink<i>Variant</i> (R)>]
    nativeRuntimeVariant[label=<nativeRuntime<i>Variant</i> (R)>]

> Task :dependencyInsight
io.vertx:vertx-lang-groovy:3.9.4
  Variant runtime:
    | Attribute Name                 | Provided     | Requested    |
    |--------------------------------|--------------|--------------|
    | org.gradle.status              | release      |              |
    | org.gradle.category            | library      | library      |
    | org.gradle.libraryelements     | jar          | jar          |

{{- define "name" -}}
    istio-cni
{{- end }}


{{- define "istio-tag" -}}
    {{ .Values.cni.tag | default .Values.global.tag }}{{with (.Values.cni.variant | default .Values.global.variant)}}-{{.}}{{end}}

 * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
 * Code distributed by Google as part of the polymer project is also
 * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 */
// Copyright (c) 2014 The Polymer Authors. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without

  // CHECK: tf.Assign
  // CHECK: tf.Read
  return
}

// -----

func.func private @id(%arg0: tensor<!tf_type.variant>) -> tensor<!tf_type.variant> {
  return %arg0 : tensor<!tf_type.variant>
}

// CHECK-LABEL: iterators
func.func private @iterators(%arg0 : tensor<!tf_type.variant>) {

        The only attribute distinguishing these variants is 'org.gradle.native.architecture'. Add this attribute to the consumer's configuration to resolve the ambiguity:
          - Value: 'x86-64' selects variant: 'natives-windows-runtime'

#ifndef HANDLE_CUSTOM_TF_TYPE
#define HANDLE_CUSTOM_TF_TYPE(class, enumerant, name) \
  HANDLE_TF_TYPE(class, enumerant, name)
#endif
HANDLE_CUSTOM_TF_TYPE(Resource, RESOURCE, "resource")
HANDLE_CUSTOM_TF_TYPE(Variant, VARIANT, "variant")
#undef HANDLE_CUSTOM_TF_TYPE

// All ref types are listed below this line and FloatRef is the first ref type.
// This helps in easily differentiating ref and non-ref types, and converting

So basically selecting the right binary for one of the above cases is a heuristic with 2 inputs:

1. Does the particular binary variant (legacy, nft, ip6tables) even exist in $PATH?
1. In the current netns context, are there already rules defined in one of (legacy, nft) tables? If so, prefer that one.

│       └── lib
│           └── app  // <2>
└── test
    ├── appTest      // <1>
    └── lib
        └── appTest  // <3>
----
<1> The script for executing the application variant
<2> The main executable binary (debug variant)
<3> The test executable binary

NOTE: When a build has dependencies, the dependent libraries are also copied into the installation folder.

dependencies {
    implementation("com.acme:lib:1.0")
}

// tag::substitution_rule[]
configurations.testCompileClasspath {
    resolutionStrategy.dependencySubstitution {
        substitute(module("com.acme:lib:1.0")).using(variant(module("com.acme:lib:1.0")) {
            capabilities {
                requireCapability("com.acme:lib-test-fixtures")
            }
        })
    }
}
// end::substitution_rule[]