* limitations under the License.
 */

package org.gradle.internal.cc.impl.cacheentry

import org.gradle.internal.hash.HashCode
import org.gradle.util.Path


internal
data class ModelKey(
    val identityPath: Path?,
    val modelName: String,
    val parameterHash: HashCode?

            BuildIdentifier buildIdentifier = buildIdentifierSerializer.read(decoder);
            Path identityPath = Path.path(decoder.readString());
            String projectName = decoder.readString();
            return new DefaultProjectComponentSelector(buildIdentifier, identityPath, Path.ROOT, projectName, readAttributes(decoder), readCapabilities(decoder));

        _ * rootProject.identityPath >> Path.path(":${name}")
        _ * rootProject.owner >> build

        return new IncludedBuildFixture(build, rootProject)
    }

    private ProjectState addProject(RootBuildFixture build, String name) {
        def projectState = Mock(ProjectState)
        projectState.projectPath >> Path.path(":$name")
        projectState.identityPath >> Path.path(":$name")

    override fun computeIfAbsent(project: ProjectState, factory: Function<ProjectState, LocalComponentGraphResolveState>): LocalComponentGraphResolveState {
        return cache.loadOrCreateProjectMetadata(project.identityPath) {
            factory.apply(project)
        }
    }

    private static class ConfigurationDescription implements Describable {
        private final Path identityPath;

        ConfigurationDescription(Path identityPath) {
            this.identityPath = identityPath;
        }

        @Override
        public String getDisplayName() {
            return "configuration '" + identityPath + "'";
        }
    }

        }
    }

    private
    fun reportProjectIsolationProblemOnApiUsage() {
        val problem = problemFactory.problem {
            text("Project ")
            reference(referrer.identityPath.toString())
            text(" cannot access task dependencies directly")
        }
            .exception()
            .build()
        problems.onProblem(problem)
    }

            sideEffect.runSideEffect()
        }
    }

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

        override fun getTarget() = delegate.target

        override fun getModel(modelName: String, parameter: ToolingModelParameterCarrier?): Any? {
            return cache.loadOrCreateIntermediateModel(target?.identityPath, modelName, parameter) {
                delegate.getModel(modelName, parameter)
            }
        }
    }

    }

    @Override
    public Path getIdentityPath() {
        if (identityPath == null) {
            identityPath = services.get(PublicBuildPath.class).getBuildPath();
        }
        return identityPath;
    }

    @Override
    public String contextualize(String description) {
        if (isRootBuild()) {
            return description;

        @Override
        public ResolvedCoordinates resolveComponentCoordinates(ProjectDependency dependency) {
            Path identityPath = ((ProjectDependencyInternal) dependency).getIdentityPath();
            return ResolvedCoordinates.create(projectDependencyResolver.resolveComponent(ModuleVersionIdentifier.class, identityPath));
        }

        @Nullable
        @Override