}

    public void kotlinDslReference(Action<? super KotlinDslReference> action) {
        action.execute(kotlinDslReference);
    }

    /**
     * This property is wired into very slow documentation generation tasks.
     *
     * Passing -PquickDocs will disable slow documentation tasks.
     *
     */
    public abstract Property<Boolean> getQuickFeedback();

 *
 * @author Sven Mawson
 * @since 15.0
 */
@GwtCompatible
public final class CharEscaperBuilder {
  /**
   * Simple decorator that turns an array of replacement char[]s into a CharEscaper, this results in
   * a very fast escape method.
   */
  private static final class CharArrayDecorator extends CharEscaper {
    private final char[] @Nullable [] replacements;
    private final int replaceLength;

Containers (mainly Linux containers) are a very **lightweight** way to package applications including all their dependencies and necessary files while keeping them isolated from other containers (other applications or components) in the same system.

///

## Returning a custom `Response` { #returning-a-custom-response }

The example above shows all the parts you need, but it's not very useful yet, as you could have just returned the `item` directly, and **FastAPI** would put it in a `JSONResponse` for you, converting it to a `dict`, etc. All that by default.

//
//go:build linux

package bytes_test

import (
	. "bytes"
	"syscall"
	"testing"
)

// This file tests the situation where byte operations are checking
// data very near to a page boundary. We want to make sure those
// operations do not read across the boundary and cause a page
// fault where they shouldn't.

// These tests run only on linux. The code being tested is

  is the DefaultExpressionEvaluator, which is a local variable within the
  implementation of the BasicComponentConfigurator. This ExpressionEvaluator
  simply returns the expression itself as the resolved value, which adds
  very little value to the container. Things like ${project.build.resources}
  are not resolved, and result in a type mismatch for the member injection.

  We need a replacement for DefaultExpressionEvaluator that is capable of

 *
 * Build up a collection by starting with [EmptyTags] and repeatedly calling [plus]. Each such call
 * returns a new instance.
 *
 * This collection is optimized for safe concurrent access over a very small number of elements.
 *
 * This collection and is expected to hold fewer than 10 elements. Each operation is _O(N)_, and so
 * building an instance with _N_ elements is _O(N**2)_.
 */
internal sealed class Tags {

     * where the property value is defined.
     */
    enum Source {
        /**
         * Maven system properties. These properties are evaluated very early during the boot process,
         * typically set by Maven itself and flagged as readOnly=true or by users via maven-system.properties files.

///

## Forbid Extra Cookies { #forbid-extra-cookies }

In some special use cases (probably not very common), you might want to **restrict** the cookies that you want to receive.

In this case, you have:

* `ItemsService`
* `UsersService`

### Client Method Names { #client-method-names }

Right now, the generated method names like `createItemItemsPost` don't look very clean:

```TypeScript
ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
```

...that's because the client generator uses the OpenAPI internal **operation ID** for each *path operation*.