*/
package org.gradle.kotlin.dsl

import org.gradle.api.reflect.TypeOf


/**
 * Creates an instance of [TypeOf] for the given parameterized type.
 *
 * @param T the type
 * @return the [TypeOf] that captures the generic type of the given parameterized type
 */
inline fun <reified T> typeOf(): TypeOf<T> =

plugins {
    application
}
// tag::snippet[]
// Extension class to capture user input
class MyExtension {
    @Input
    var inputParameter: String? = null
}

// Custom task that uses the input from the extension
class MyCustomTask : org.gradle.api.DefaultTask() {
    @Input
    var inputParameter: String? = null

    @TaskAction
    fun executeTask() {
        println("Input parameter: $inputParameter")
    }
}

// callable for each one. `key` and `value` is only usable during the callback.
// `capture` will be passed to the callback without modification.
#define TF_PayloadVisitor TSL_PayloadVisitor
TF_CAPI_EXPORT extern void TF_ForEachPayload(const TF_Status* s,
                                             TF_PayloadVisitor visitor,
                                             void* capture);

// Convert from an I/O error code (e.g., errno) to a TF_Status value.

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package capture

import "strings"

func FormatIptablesCommands(commands [][]string) []string {
	output := make([]string, 0, len(commands))
	for _, cmd := range commands {
		output = append(output, strings.Join(cmd, " "))
	}

# Verify for functions with control return values, the island with a consumed
# data output and a consumed control has both its outputs added to the GraphOps
# FetchOp.

# Match the island containing the "tf.Neg", capture the output
# CHECK:          %[[ISLAND:[a-z_0-9]*]], %[[ISLAND_control:[a-z_0-9]*]] = tf_executor.island wraps "tf.Neg"

# Check that the tf.Neg data output and control are passed to the fetch

plugins {
    id 'application'
}
// tag::snippet[]
// Extension class to capture user input
class MyExtension {
    @Input
    String inputParameter = null
}

// Custom task that uses the input from the extension
class MyCustomTask extends DefaultTask {
    @Input
    String inputParameter = null

    @TaskAction
    def executeTask() {
        println("Input parameter: $inputParameter")
    }
}

/workloadapi/workload.proto) and [`Authorization`](../../pkg/workloadapi/security/authorization.proto). As such, ztunnel does not receive `PeerAuthentication`s directly; when istiod detects a `PeerAuthentication` resource that targets an Ambient captured workload, it computes the effective policy for that workload (taking into account the mesh-wide -> namespace -> workload precedence rules) and sends that policy to ztunnel. The exact details of this conversion is out of scope for this document at...

  // Test that the quantized op is captured in `results`.
  const QuantizationResult& quantized_result = results.results(0);
  EXPECT_THAT(quantized_result.quantizable_unit().name(),
              StrEq("composite_dot_general_fn_2"));
  EXPECT_TRUE(quantized_result.method().has_static_range_ptq());

  // Test that the non-quantized op is captured in `results`.

     * @return this
     */
    CopyProcessingSpec rename(String sourceRegEx, String replaceWith);

    /**
     * Renames files based on a regular expression. See {@link #rename(String, String)}.
     *
     * @param sourceRegEx Source regular expression
     * @param replaceWith Replacement string (use $ syntax for capture groups)
     * @return this
     */

package org.gradle.internal.execution.history;

import com.google.common.collect.ImmutableSortedMap;
import org.gradle.internal.fingerprint.CurrentFileCollectionFingerprint;
import org.gradle.internal.hash.HashCode;

/**
 * Captures the state of a {@link org.gradle.internal.execution.UnitOfWork} after it has been executed.
 *
 * Execution here might also mean being up-to-date or loaded from cache.
 */