}

        override fun <T> resolveScriptsForProject(identityPath: Path, action: () -> T): T {
            return fingerprintWriter.runCollectingFingerprintForProject(identityPath, action)
        }

        override fun <T> runCollectingFingerprintForProject(identityPath: Path, action: () -> T): T {
            return fingerprintWriter.runCollectingFingerprintForProject(identityPath, action)
        }

        readString()

    private
    fun identifyBuild(state: CachedBuildState) {
        val identityPath = state.identityPath.toString()

        eventEmitter.emitNowForCurrent(BuildIdentifiedProgressDetails { identityPath })

        if (state is BuildWithProjects) {
            val projects = convertProjects(state.projects, state.rootProjectName)

    }

    override fun onProjectReference(referrer: ProjectState, target: ProjectState) {
        if (referrer.identityPath == target.identityPath)
            return

        if (host.cacheIntermediateModels) {
            val dependency = ProjectSpecificFingerprint.CoupledProjects(referrer.identityPath, target.identityPath)
            if (projectDependencies.add(dependency)) {
                projectScopedWriter.write(dependency)

            sideEffect.runSideEffect()
        }
    }

    override fun <T> loadOrCreateIntermediateModel(identityPath: Path?, modelName: String, parameter: ToolingModelParameterCarrier?, creator: () -> T?): T? {
        return intermediateModels.loadOrCreateIntermediateModel(identityPath, modelName, parameter, creator)
    }

                            def builds = []
                            registry.visitBuilds { b ->
                                builds.add(b.identityPath.path)
                                if (b.projectsLoaded) {
                                    projects.addAll(b.projects.allProjects.collect { p -> p.identityPath.path })
                                }
                            }
                            println "projects = " + projects

        addBuilderRegisteringPluginImplementation(childBuildName, "MyModelBuilder", """
            def model = project.extensions.create("myExtension", MyExtension)
            model.message = "It works from project \${project.identityPath}"
        """)
    }

    void withParameterizedSomeToolingModelBuilderPluginInChildBuild(String childBuildName, String builderContent = "") {
        addPluginBuildScript(childBuildName)

    withIsolate(IsolateOwners.OwnerTask(task), codec) {
        withPropertyTrace(PropertyTrace.Task(taskType, task.identityPath.path)) {
            if (task.isCompatibleWithConfigurationCache) {
                action()
            } else {
                forIncompatibleType(task.identityPath.path, action)
            }
        }
    }
}


private
sealed class RegisteredProperty {

        }

        override fun getPluginManager(): PluginManagerInternal {
            onAccess("pluginManager")
            return delegate.pluginManager
        }

        override fun identityPath(name: String): Path {
            shouldNotBeUsed()
        }

        override fun projectPath(name: String): Path {
            shouldNotBeUsed()
        }

                addressSerializer.write(this, it)
            }
        }
    }

    private
    fun DefaultWriteContext.writeModelKey(key: ModelKey) {
        writeNullableString(key.identityPath?.path)
        writeString(key.modelName)
        writeNullableString(key.parameterHash?.toString())
    }

    internal
    fun readCacheEntryDetailsFrom(stateFile: ConfigurationCacheStateFile): EntryDetails? {

    override fun setIncludedBuilds(includedBuilds: MutableCollection<out IncludedBuildInternal>) {
        delegate.setIncludedBuilds(includedBuilds)
    }

    override fun getIdentityPath(): Path =
        delegate.identityPath

    override fun contextualize(description: String): String =
        delegate.contextualize(description)

    override fun getPublicBuildPath(): PublicBuildPath =
        delegate.publicBuildPath