}
	if configs := b.build(b.allowPolicies, rbacpb.RBAC_ALLOW, false); configs != nil {
		b.logger.AppendDebugf("built %d HTTP filters for ALLOW action", len(configs.http))
		filters = append(filters, configs.http...)
	}
	return filters
}

// BuildTCP returns the TCP filters built from the authorization policy.
func (b Builder) BuildTCP() []*listener.Filter {
	b.logger = &AuthzLogger{}

/**
 * <p>
 * A {@link Builder} encapsulates a strategy for building a set of Maven projects. The default strategy in Maven builds
 * the projects serially, but a {@link Builder} can employ any type of concurrency model to build the projects.
 * </p>
 * <strong>Note:</strong> This interface is part of work in progress and can be changed or removed without notice.
 */
public interface Builder {
    //

func (c *CRDCanonicalTypeNamer) OpenAPICanonicalTypeName() string {
	return fmt.Sprintf("%s/%s.%s", c.group, c.version, c.kind)
}

// builder contains validation schema and basic naming information for a CRD in
// one version. The builder works to build a WebService that kube-openapi can
// consume.
type builder struct {
	schema     *spec.Schema
	listSchema *spec.Schema
	ws         *restful.WebService

	group    string

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)

		// the binary's build ID, so it is the same hash used in
		// compiling and linking.
		// When compiling, we use actionID/actionID (instead of
		// actionID/contentID) as a temporary build ID to compute
		// the hash. Do the same here. (See buildid.go:useCache)
		// The build ID matters because it affects the overall hash
		// in the plugin's pseudo-import path returned below.

plugins {
    id 'java-gradle-plugin'
}

group = 'reporters'

repositories {
    mavenCentral()
}

gradlePlugin {
    plugins {
        'model-builder-plugin' {
            id = 'reporters.model.builder'
            implementationClass = 'reporters.ModelBuilderPlugin'
        }
    }

// tag::type-registration[]
// tag::internal-view-mutation[]
class MyPlugin extends RuleSource {
// end::internal-view-mutation[]
    @ComponentType
    void registerMyComponent(TypeBuilder<MyComponent> builder) {
        builder.internalView(MyComponentInternal)
    }
// end::type-registration[]
// tag::internal-view-mutation[]
    @Mutate
    void mutateMyComponents(ModelMap<MyComponentInternal> components) {

fun test() {
    buildFoo {
        value = <expr>produceString()</expr>
    }
}

fun buildFoo(builder: Foo.() -> Unit): Foo {
    val foo = Foo()
    foo.builder()
    return foo
}

fun Foo {
    var value: String? = null
}

fun test() {
    buildFoo {
        <expr>value</expr> = produceString()
    }
}

fun buildFoo(builder: Foo.() -> Unit): Foo {
    val foo = Foo()
    foo.builder()
    return foo
}

class Foo {
    var value: String? = null
}

plugins {
    id 'reporters.model.builder'