switch g {
{{- range .Entries }}
	{{- if not (or (eq .Resource.Identifier "Address") (eq .Resource.Identifier "DNSName")) }}
		case gvk.{{.Resource.Identifier}}:
			return {{.Resource.Identifier}}
	{{- end }}
{{- end }}
	}

	panic("unknown kind: " + g.String())

        return calculatedValueFactory.create(toDisplayName(identifier), () -> resolveModule((ModuleComponentIdentifier) identifier, componentOverrideMetadata));
    }

    @Override
    public boolean isFetchingMetadataCheap(ComponentIdentifier identifier) {
        if (identifier instanceof ModuleComponentIdentifier) {

        given:
        def identifier = newId(mid, '1.1')
        startWithoutLockState()
        addVisitedChangingNode(identifier)

        when:
        visitor.writeLocks()

        then:
        1 * dependencyLockingProvider.persistResolvedDependencies(lockId, _, singleton(identifier), singleton(identifier))

    }

    def 'ignores visited node that is to be ignored'() {

        then:
        outputProbe.value == """
{identifier} + Options{normal}
     | Auto-detection:     {description}Enabled{normal}
     | Auto-download:      {description}Enabled{normal}

{identifier} + Invalid toolchains{normal}
{identifier}     + path{normal}
       | Error:              {description}errorMessage{normal}
{identifier}     + path{normal}

        super(exported, attributes, accessRules);
        this.file = file;
        this.javadoc = javadoc;
        this.source = source;
        this.identifier = identifier;
        this.moduleVersion = (identifier == null) ? null : new DefaultGradleModuleVersion(identifier);
        this.resolved = resolved;
        this.attemptedSelector = (attemptedSelector == null) ? null : new DefaultEclipseComponentSelector(attemptedSelector);
    }

	switch g {
{{- range $entry := .Entries }}
		case {{$entry.Resource.Identifier}}:
			return gvr.{{$entry.Resource.Identifier}}, true
	{{- range $alias := .Resource.VersionAliases }}
		case {{$entry.Resource.Identifier}}_{{$alias}}:
			return gvr.{{$entry.Resource.Identifier}}_{{$alias}}, true
    {{- end }}
{{- end }}
	}

	return schema.GroupVersionResource{}, false
}

{{ .CustomImport }}
  "reflect"
{{- range .Packages}}
	{{.ImportName}} "{{.PackageName}}"
{{- end}}
)

var (
{{ range .Entries }}
	{{ .Resource.Identifier }} = resource.Builder {
			Identifier: "{{ .Resource.Identifier }}",
			Group: "{{ .Resource.Group }}",
			Kind: "{{ .Resource.Kind }}",
			Plural: "{{ .Resource.Plural }}",
			Version: "{{ .Resource.Version }}",
			{{- if .Resource.VersionAliases }}

    private final ComponentSpecIdentifier identifier;
    private final Class<?> publicType;

    public AbstractComponentSpec(ComponentSpecIdentifier identifier, Class<?> publicType) {
        this.publicType = publicType;
        this.identifier = identifier;
    }

    @Override
    public ComponentSpecIdentifier getIdentifier() {
        return identifier;
    }

    @Override
    public String getName() {

        where:
        identifier << Identifier.all
    }

    def "can publish artifacts with version, extension and classifier containing #identifier characters"() {
        given:
        file("content-file") << "some content"
        def version = identifier.safeForFileName().decorate("version")
        def extension = identifier.safeForFileName().decorate("extension")

internal
class UnexpectedDuplicateBlock(val identifier: TopLevelBlockId, override val location: IntRange) :
    UnexpectedBlock("Unexpected `$identifier` block found. Only one `$identifier` block is allowed per script.")


internal
class UnexpectedBlockOrder(val identifier: TopLevelBlockId, override val location: IntRange, expectedFirstIdentifier: TopLevelBlockId) :