}
        }
    }

    private
    fun ReadContext.readNodeGroup(nodesById: Map<Int, Node>): NodeGroup {
        return decodePreservingIdentity { id ->
            when (readSmallInt()) {
                0 -> {
                    val ordinal = readSmallInt()
                    ordinalGroups.group(ordinal)
                }

                1 -> {

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "A set of generic services and utilities specific for Groovy."

dependencies {
    api(project(":base-services"))
    api(projects.stdlibJavaExtensions)

    api(libs.jsr305)
    api(libs.groovy)
    api(libs.guava)

    testImplementation(testFixtures(project(":core")))

            writeCollection(value.copyActions)
            writeCollection(value.children)
        }
    }

    override suspend fun ReadContext.decode(): DefaultCopySpec {
        return decodePreservingIdentity { id ->
            val destPath = readNullableString()
            val sourceFiles = read() as FileCollection
            val patterns = read() as PatternSet
            val duplicatesStrategy = readEnum<DuplicatesStrategy>()

import gradlebuild.integrationtests.configureIde
import gradlebuild.integrationtests.createTestTask
import gradlebuild.integrationtests.setSystemPropertiesOfTestJVM

plugins {
    java
    id("gradlebuild.module-identity")
    id("gradlebuild.dependency-modules")
}

val sourceSet = addSourceSet(TestType.CROSSVERSION)
addDependenciesAndConfigurations(TestType.CROSSVERSION.prefix)
createQuickFeedbackTasks()

                val stepsWithSchemaStoring = evaluationSchemaForScript.sequence.steps.map {
                    val schemaHandler: (String, AnalysisSchema) -> Unit = { id, schema -> storeSchemaResult(id, schema) }
                    when (it) {
                        is InterpretationSequenceStepWithConversion<*> -> SchemaHandlingInterpretationSequenceStepWithConversion(it, schemaHandler)

plugins {
    id("gradlebuild.distribution.implementation-kotlin")
}

description = "Declarative DSL Tooling Builders for IDEs"

dependencies {
    api(projects.serviceProvider)
    api(project(":core"))
    api(project(":core-api"))

    api(libs.kotlinStdlib)

    implementation(projects.stdlibJavaExtensions)
    implementation(project(":declarative-dsl-evaluator"))
    implementation(project(":declarative-dsl-provider"))

    val flameGraphs: List<FlameGraphGeneration> = emptyList(),
    val trigger: Trigger = Trigger.never,
    val runsIndependent: Boolean = false
) {
    val id = stageName.id
}

data class DocsTestCoverage(val os: Os, val testJava: JvmCategory, val docsTestTypes: List<DocsTestType>)

data class TestCoverage(
    val uuid: Int,
    val testType: TestType,
    val os: Os,

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.implementation-kotlin")
    id("gradlebuild.kotlin-dsl-sam-with-receiver")
}

description = "Base utilities and services to report and track configuration problems"

dependencies {
    api(projects.baseServices)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.implementation-kotlin")
    id("gradlebuild.kotlin-dsl-sam-with-receiver")
}

description = "Configuration Cache services supporting bean serialization"

dependencies {
    api(projects.graphSerialization)

        }
        return symbolEquals(other)
    }

    /**
     * All kinds of non-local named class or object symbols must have the same kind of hash code. The class ID is the best option, as the
     * same class/object may be represented by multiple different symbols.
     */
    override fun hashCode(): Int = classId?.hashCode() ?: symbolHashCode()