package org.gradle.model.internal.core;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Applied together with {@link org.gradle.model.Model} annotation the registered model element
 * will not be shown in reports.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Hidden {

//     dependencies of the application and its plugins are built from
//     exactly the same source code.
//
//   - Together, these restrictions mean that, in practice, the
//     application and its plugins must all be built together by a
//     single person or component of a system. In that case, it may
//     be simpler for that person or component to generate Go source

import org.gradle.language.nativeplatform.DependentSourceSet;
import org.gradle.language.nativeplatform.HeaderExportingSourceSet;

/**
 * A set of C source files.
 *
 * <p>A C source set contains a set of source files, together with an optional set of exported header files.</p>
 *
 * <pre class='autoTested'>
 * plugins {
 *     id 'c'
 * }
 *
 * model {
 *     components {
 *         main(NativeLibrarySpec) {

// tag::use[]
// Iterate over the contents of a tree
tree.each {File file ->
    println file
}

// Filter a tree
FileTree filtered = tree.matching {
    include 'org/gradle/api/**'
}

// Add trees together
FileTree sum = tree + fileTree(dir: 'src/test')

// Visit the elements of the tree
tree.visit {element ->
    println "$element.relativePath => $element.file"
}
// end::use[]

// tag::archive-trees[]

    // The jacoco plugin does not add tasks to an empty project.
    // We apply the java plugin too here in this test to check that
    // the jacoco plugin behaves well when used together
    // with the java plugin (a typical scenario).

    def setup(){
        buildFile << """
            apply plugin:'java'
        """
    }

    /**
     * Returns all schemas that are implemented by this struct. These schemas include the public view schema, any internal view schemas specified
     * when declaring the struct, together with all their super-type schemas. This is an exhaustive list of every type a node can be
     * viewed as. In other words this is the full list of interfaces that a view proxy class generated for this struct type might implement.

#include <string>

namespace mlir::quant::stablehlo {

// Introduces aliases for `std::string` to distinguish btw. function name and
// its alias, to prevent confusion when used together in a container. For
// example, it is easy to confuse function name -> alias mapping with alias ->
// function name mapping when both are just represented as `std::string`.
using FunctionAlias = std::string;

// Iterate over the contents of a tree
tree.forEach{ file: File ->
    println(file)
}

// Filter a tree
val filtered: FileTree = tree.matching {
    include("org/gradle/api/**")
}

// Add trees together
val sum: FileTree = tree + fileTree("src/test")

// Visit the elements of the tree
tree.visit {
    println("${this.relativePath} => ${this.file}")
}
// end::use[]

// tag::archive-trees[]

app: {{ (.Values.labels.app | quote) | default (include "gateway.name" .) }}
istio: {{ (.Values.labels.istio | quote) | default (include "gateway.name" . | trimPrefix "istio-") }}
{{- end }}

{{/*
Keep sidecar injection labels together
https://istio.io/latest/docs/setup/additional-setup/sidecar-injection/#controlling-the-injection-policy
*/}}
{{- define "gateway.sidecarInjectionLabels" -}}
sidecar.istio.io/inject: "true"
{{- with .Values.revision }}

import org.gradle.internal.execution.steps.Result;
import org.gradle.internal.execution.steps.Step;

/**
 * This is a temporary measure for Gradle tasks to track a legacy measurement of all input snapshotting together.
 */
public class MarkSnapshottingInputsStartedStep<C extends Context, R extends Result> implements Step<C, R> {
    private final Step<? super C, ? extends R> delegate;