4. <<nameddomainobjectcontainer,`NamedDomainObjectContainer<T>`>>: A container for managing objects of type T, where each object has a unique name. This container provides methods for adding, removing, and querying objects by name.

    int periodicCheckInterval = 5
    //normally, state transition timeout must be lower than the daemon timeout
    //so that the daemon does not timeout in the middle of the state verification
    //effectively hiding some bugs or making tests fail
    int stateTransitionTimeout = daemonIdleTimeout / 2

    final List<GradleHandle> builds = []
    final List<GradleHandle> foregroundDaemons = []

https://blog.jetbrains.com/kotlin/2018/01/kotlin-1-2-20-is-out/[You can opt into it] (which is recommended) by adding the following to build scripts:

====
include::sample[dir="snippets/buildCache/caching-android-projects/kotlin",files="build.gradle.kts[tags=cacheKapt]"]

- **Windows**: C:\Users\[username]\.m2

A publication destined for a Maven repository normally includes:

- One or more artifacts
- The Gradle Module Metadata
- The Maven POM file

Apply the plugin by adding `maven-publish` to the plugins block in `build.gradle(.kts)`:

[.multi-language-sample]
=====
[source, kotlin]
----
plugins {
    // Apply the application plugin to add support for building a CLI application in Java.

        when:
        def allArgs = executer.getAllArgs()

        then:
        !allArgs.contains("--daemon")
        allArgs.contains("--no-daemon")
    }

    def "when --foreground argument is added, it skips adding --daemon/--no-daemon"() {
        when:
        executer.withArgument("--foreground")
        def allArgs = executer.getAllArgs()

        then:
        !allArgs.contains("--daemon")

Since you cannot use the `-P` option in that scenario nor change the system-level configuration files, the correct strategy is to change the configuration of your continuous integration build job, adding an environment variable setting that matches an expected pattern.
This won't be visible to normal users on the system.

The following examples demonstrate how to use project properties.

import java.lang.reflect.WildcardType;

import static org.objectweb.asm.Type.getType;

public class AsmClassGeneratorUtils {

    /**
     * Generates the signature for the given constructor, optionally adding a `name` parameter before all other parameters.
     */
    public static String signature(Constructor<?> constructor, boolean addNameParameter) {
        StringBuilder builder = new StringBuilder();

import org.gradle.api.artifacts.PublishArtifact;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * This class is for defining artifacts to be published and adding them to configurations. Creating publish artifacts
 * does not mean to create an archive. What is created is a domain object which represents a file to be published
 * and information on how it should be published (e.g. the name).
 *

  // possible after the object is created.
  explicit linked_ptr(T* ptr = NULL) { capture(ptr); }
  ~linked_ptr() { depart(); }

  // Copy an existing linked_ptr<>, adding ourselves to the list of references.
  template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); }
  linked_ptr(linked_ptr const& ptr) {  // NOLINT
    assert(&ptr != this);
    copy(&ptr);
  }

        mavenCentral()
    }
}
----

You can also include version catalogs in this section.

=== 5. Add subprojects to the build

The settings file defines the structure of the project by adding all the subprojects using the link:{javadocPath}/org/gradle/api/initialization/Settings.html[`include`] statement:

[source,kotlin]
----
include("app")
include("business-logic")
include("data-model")
----