}

  // We assume all other TF operators are flex delegated.
  return op->getDialect()->getNamespace() == "tf";
}

// This is a variation of the algorithm from
// llvm/llvm-project/mlir/lib/Transforms/Utils/TopologicalSortUtils.cpp.
//
// Takes a function object `partition` that maps operations to one of two types
// (for the current use case, flex delegate or not.)
//

include::sample[dir="snippets/tutorial/projectProperties/groovy",files="build.gradle[tags=configuration]"]
====

[.multi-language-text.lang-kotlin]
The link:https://kotlinlang.org/docs/delegated-properties.html[Kotlin delegated properties] are part of the Gradle Kotlin DSL.
You need to explicitly specify the type as `String`.
If you need to branch depending on the presence of the property, you can also use `String?` and check for `null`.

                return symbol.getCombinedDeclaredMemberScope().getAllSymbols()
                    .filter { member ->
                        val origin = member.origin
                        origin != KaSymbolOrigin.DELEGATED &&
                                origin != KaSymbolOrigin.SOURCE_MEMBER_GENERATED &&
                                origin != KaSymbolOrigin.SUBSTITUTION_OVERRIDE &&

# apiserver

Generic library for building a Kubernetes aggregated API server.


## Purpose

This library contains code to create Kubernetes aggregation server complete with delegated authentication and authorization,
`kubectl` compatible discovery information, optional admission chain, and versioned types.  It's first consumers are
`k8s.io/kubernetes`, `k8s.io/kube-aggregator`, and `github.com/kubernetes-incubator/service-catalog`.


## Compatibility

	}
	w.hijacked = true
	klog.V(6).Infof("Hijack returning websocket tunneling net.Conn")
	return w.conn, nil, nil
}

// Header is delegated to the stored "http.ResponseWriter".
func (w *tunnelingResponseWriter) Header() http.Header {
	return w.w.Header()
}

// Write is delegated to the stored "http.ResponseWriter".
func (w *tunnelingResponseWriter) Write(p []byte) (int, error) {
	w.mu.Lock()
	defer w.mu.Unlock()

        twoStageArtifactsCache.get(key)

        then:
        1 * writeCache.get(key) >> Stub(AbstractArtifactsCache.ModuleArtifactsCacheEntry)
        0 * readCache.get(key)
    }

    def "writes are delegated to the writable cache"() {
        def entry = Stub(AbstractArtifactsCache.ModuleArtifactsCacheEntry)
        when:
        twoStageArtifactsCache.store(key, entry)

        then:
        writeCache.store(key, entry)

	"k8s.io/apiserver/pkg/authentication/authenticator"
	"k8s.io/apiserver/pkg/authentication/user"
)

// GroupAdder adds groups to an authenticated user.Info
type GroupAdder struct {
	// Authenticator is delegated to make the authentication decision
	Authenticator authenticator.Request
	// Groups are additional groups to add to the user.Info from a successful authentication
	Groups []string
}

            verify(clean).delete("things")
            verify(clean).delete("build")
        }
    }

    @Test
    fun `can create element within configuration block via delegated property`() {

        val tasks = mock<TaskContainer> {
            on { create("hello") } doReturn mock<Task>()
        }

        tasks {
            @Suppress("unused_variable")

	"k8s.io/apiserver/pkg/authentication/user"
)

// AuthenticatedGroupAdder adds system:authenticated group when appropriate
type AuthenticatedGroupAdder struct {
	// Authenticator is delegated to make the authentication decision
	Authenticator authenticator.Request
}

// NewAuthenticatedGroupAdder wraps a request authenticator, and adds the system:authenticated group when appropriate.

    /** Represents a delegated local variable (`val local by...`). */
    public class LocalDelegate(
        name: Name,
        isMutated: Boolean,
        isCrossingInlineBounds: Boolean,
    ) : CodeFragmentCapturedValue(name.asString(), isMutated, isCrossingInlineBounds) {
        override val displayText: String
            get() = "$name\$delegate"
    }