dependencies {
    implementation(projects.buildCache)
    implementation(projects.buildCacheBase)
    implementation(projects.buildCacheLocal)
    implementation(projects.buildCachePackaging)
    implementation(projects.buildCacheSpi)
    implementation(projects.buildOperations)
    implementation(projects.concurrent)
    implementation(projects.fileTemp)
    implementation(projects.files)
    implementation(projects.functional)

dependencies {
    api(projects.configurationProblemsBase)
    api(projects.core)
    api(projects.coreApi)
    api(projects.graphSerialization)
    api(projects.stdlibJavaExtensions)
    api(projects.loggingApi)

    api(libs.kotlinStdlib)

    implementation(projects.baseServices)

In configuration-on-demand mode, projects are configured as follows:

* The root project is always configured.
* The project in the directory where the build is executed is also configured, but only when Gradle is executed without any tasks. +
This way, the default tasks behave correctly when projects are configured on demand.
* The standard project dependencies are supported, and relevant projects are configured. +

        def workspace = eclipseWorkspace([
            project("root", projectDir), gradleProject("a"), project("explicitName", file("b")),
            externalProject("root-a"),
            project("includedBuild1", inc1), project("includedBuild1-a", inc1.file("a")), project("includedBuild1-includedBuild1-b", inc1.file("b")), project("includedBuild1-c", inc1.file("c")),
            externalProject("includedBuild1-b"),

}

description = "Serialization codecs for stdlib types"

dependencies {
    api(projects.graphSerialization)
    api(libs.kotlinStdlib)

    implementation(projects.baseServices)
    implementation(projects.configurationProblemsBase)
    implementation(projects.serialization)
    implementation(projects.stdlibKotlinExtensions)

            throws DuplicateProjectException {
        Map<String, MavenProject> index = new LinkedHashMap<>();
        Map<String, List<File>> collisions = new LinkedHashMap<>();

        for (MavenProject project : projects) {
            String projectId = ArtifactUtils.key(project.getGroupId(), project.getArtifactId(), project.getVersion());

    public interface ReportAction<T> {
        void execute(T project) throws IOException;
    }

    public void generateReport(Set<Project> projects, ReportAction<Project> projectReportGenerator) {
        generateReport(projects, ProjectDetails::of, projectReportGenerator);
    }

    public <T> void generateReport(
        Iterable<T> projects,
        Function<T, ProjectDetails> projectDetailsProvider,

    }

    private
    fun applyProjectStates(projects: List<CachedProjectState>, gradle: GradleInternal) {
        for (project in projects) {
            if (project is ProjectWithWork && project.normalizationState != null) {
                val projectState = gradle.owner.projects.getProject(project.path)
                projectState.mutableModel.normalization.configureFromCachedState(project.normalizationState)
            }
        }

  <profiles>

    <profile>
      <id>property-name-project-version</id>
      <activation>
        <property>
          <name>${project.version}</name>
        </property>
      </activation>
    </profile>
    <profile>
      <id>property-value-project-version</id>
      <activation>
        <property>
          <name>project.version</name>
          <value>${project.version}</value>
        </property>
      </activation>

    api(project(":jvm-services"))
    api(project(":language-java"))
    api(project(":language-jvm"))
    api(project(":problems-api"))
    api(project(":platform-base"))
    api(project(":toolchains-jvm"))
    api(project(":toolchains-jvm-shared"))
    api(project(":workers"))
    api(project(":worker-main"))
    api(project(":build-process-services"))

    api(libs.inject)
    api(libs.jsr305)