"k8s.io/apimachinery/pkg/runtime/schema"
)

// include is the list of resources that the expression-based admission controllers
// should intercept.
// The version is omitted, all versions of the same GroupResource are treated the same.
// If a resource is transient, i.e., not persisted in the storage, the resource must be
// in either include or excluded list.
var included = []schema.GroupResource{
	{Group: "", Resource: "bindings"},

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 49489
releaseNotes:
  - |

 */
public interface ModuleComponentRepository<T> {
    /**
     * A unique identifier for this repository, based on its type and attributes.
     * Two repositories with the same configuration will share the same id.
     * This id is stable across builds on the same machine.
     *
     * <p>The name is not encoded in the id, as it is not relevant for resolution. The name is only used for diagnotics.</p>
     */
    String getId();

    IterationOrderRetainingSetElementSource<CharSequence> source = new IterationOrderRetainingSetElementSource<>()

    def "can add the same provider twice"() {
        def provider = provider("foo")

        when:
        source.addPending(provider)
        source.addPending(provider)

        then:
        source.size() == 1

 *
 * Here, the term "build" is used to represent the overall invocation.
 * For example, buildSrc shares the same build scope ID as the overall build.
 * All composite participants also share the same build scope ID.
 * That is, all “nested” build trees (in terms of GradleLauncher, GradleBuild etc.) share the same build invocation ID.
 *
 * This ID is, by definition, not persistent.
 */
@ServiceScope(Scope.BuildTree.class)

!!! note "Technical Details"
    You could also use `from starlette.templating import Jinja2Templates`.

    **FastAPI** provides the same `starlette.templating` as `fastapi.templating` just as a convenience for you, the developer. But most of the available responses come directly from Starlette. The same with `Request` and `StaticFiles`.

## Writing templates

Then you can write a template at `templates/item.html` with, for example:

query_or_cookie_extractor(["query_or_cookie_extractor"])

read_query["/items/"]

query_extractor --> query_or_cookie_extractor --> read_query
```

## Using the same dependency multiple times

If one of your dependencies is declared multiple times for the same *path operation*, for example, multiple dependencies have a common sub-dependency, **FastAPI** will know to call that sub-dependency only once per request.

    }

    def "equals and hash code differentiate between same and different instances"() {
        when:
        def metadata = new PublishArtifactLocalArtifactMetadata(newComponentId("foo"), newPublishArtifact("name", "type", "ext", "classifier", "name-1234.jar"))

// a named type remain the same as long as the same source and AddMethod calls
// are presented to the type checker in the same order (go.dev/issue/61298).
func TestMethodOrdering(t *testing.T) {
	const src = `
package p

type T struct{}

func (T) a() {}
func (T) c() {}
func (T) b() {}
`
	// should get the same method order each time
	var methods []string

        nameOnly.displayName == "name-version (group:module:version)"
        nameOnly.toString() == "name-version (group:module:version)"
    }

    def "has same string representation as a ComponentFileArtifactIdentifier that carries the same information"() {
        def componentId = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("group", "module"), "version")

        expect: