class Initial() : State() {

            private
            val actions = mutableListOf<RegisteredFlowAction>()

            override val pendingActions: List<RegisteredFlowAction>
                get() = actions

            override fun add(registeredFlowAction: RegisteredFlowAction) {
                synchronized(actions) {
                    actions.add(registeredFlowAction)
                }
            }

        executeObjectConfigurationAction { configure(it) }
    }

    internal
    fun applyObjectConfigurationAction(options: Map<String, *>) {
        executeObjectConfigurationAction { configureByMap(options, it) }
    }

    private
    inline fun executeObjectConfigurationAction(configure: (ObjectConfigurationAction) -> Unit) {

    }

    jmhImplementation(platform(project(":distributions-dependencies")))
}

strictCompile {
    ignoreRawTypes() // raw types used in public API
}

tasks.withType<JavaCompile>().configureEach {
    options.release = null
    sourceCompatibility = "8"
    targetCompatibility = "8"
}

integTest.usesJavadocCodeSnippets = true

packageCycles {
    excludePatterns.add("org/gradle/model/internal/core/**")

        select(
            "testJavaVendor",
            JvmVendor.openjdk.name,
            display = ParameterDisplay.PROMPT,
            description = "The java vendor to run the performance tests",
            options = JvmVendor.values().map { it.displayName to it.name }
        )
        when (os) {
            Os.WINDOWS -> {
                profilerParam("jprofiler")

import org.gradle.api.tasks.compile.JavaCompile
import org.gradle.kotlin.dsl.*


/**
 * Strict compilation options honored by [gradlebuild.Strict_compile_gradle].
 */
abstract class StrictCompileExtension(val tasks: TaskContainer) {

    fun ignoreDeprecations() {
        tasks.withType<JavaCompile>().configureEach {
            options.compilerArgs.add("-Xlint:-deprecation")
        }
    }

    fun ignoreRawTypes() {

     */
    val loadAfterStore: Boolean = !modelParameters.isRequiresBuildModel && options.getInternalFlag("org.gradle.configuration-cache.internal.load-after-store", true)

    val taskExecutionAccessPreStable: Boolean = options.getInternalFlag("org.gradle.configuration-cache.internal.task-execution-access-pre-stable")

    val encryptionRequested: Boolean = options.getInternalFlag("org.gradle.configuration-cache.internal.encryption", true)

/**
 * Schedules the writing of the given [file].
 */
fun IO.writeFile(file: File, bytes: ByteArray) = io {
    file.writeBytes(bytes)
}


/**
 * A scope for the scheduling of IO actions.
 *
 * [close] guarantees all scheduled IO actions are executed before returning.
 *
 * Each [IOScope] operates independently and failures in one [IOScope]
 * do not affect existing or future [IOScope]s.
 *

        delegate.apply(closure)

    override fun apply(action: Action<in ObjectConfigurationAction>) =
        delegate.apply(action)

    override fun apply(options: Map<String, *>) =
        delegate.apply(options)

    override fun getPluginManager(): PluginManager =
        delegate.pluginManager

    override fun getExtensions(): ExtensionContainer =
        delegate.extensions

    override fun beforeEvaluate(project: Project) {
        val actions = isolatedActions()
        // preserve isolate semantics between `beforeProject` and `afterProject`
        project.setSingletonProperty(actions)
        executeAll(actions.beforeProject, project)
    }

    override fun afterEvaluate(project: Project, state: ProjectState) {
        val actions = project.popSingletonProperty<IsolatedProjectActions>()

            val fileMode = readNullableSmallInt()
            val actions = readList().uncheckedCast<List<Action<FileCopyDetails>>>()
            val children = readList().uncheckedCast<List<CopySpecInternal>>()
            val copySpec = DefaultCopySpec(fileCollectionFactory, objectFactory, instantiator, patternSetFactory, destPath, sourceFiles, patterns, actions, children)
            copySpec.duplicatesStrategy = duplicatesStrategy