) : ConfigurationCacheStateFile {
        override val exists: Boolean
            get() = file.isFile

        override val stateFile: StateFile
            get() = StateFile(stateType, file)

        override fun outputStream(): OutputStream =
            throw UnsupportedOperationException()

        override fun inputStream(): InputStream =
            file.also(::markAccessed).inputStream()

        override fun delete() {

     */
    ProjectState stateFor(Project project) throws IllegalArgumentException;

    /**
     * Locates the state object that owns the project with the given identifier.
     */
    ProjectState stateFor(ProjectComponentIdentifier identifier) throws IllegalArgumentException;

    /**

    })


private
object LoadDetails : ConfigurationCacheLoadBuildOperationType.Details


internal
data class LoadResult(val stateFile: File, val originInvocationId: String? = null) : ConfigurationCacheLoadBuildOperationType.Result {
    override fun getCacheEntrySize(): Long = stateFile.length()
    override fun getOriginBuildInvocationId(): String? = originInvocationId
}


private

# Verify that TensorFlow If and StatelessIf ops are mapped to the
# composite If op in MLIR with is_stateless attribute set accordingly to
# distinguish between them.

# CHECK-DAG: "tf.If"{{.*}} is_stateless = false{{.*}} loc(fused["If:", "StatefulIf"])

        this.idGenerator = idFactory;
        this.attributeDesugaring = attributeDesugaring;
    }

    public ModuleComponentGraphResolveState stateFor(ModuleComponentResolveMetadata metadata) {
        if (metadata instanceof IvyModuleResolveMetadata) {
            IvyModuleResolveMetadata ivyMetadata = (IvyModuleResolveMetadata) metadata;

import org.gradle.cache.internal.streams.ValueStore
import java.io.File


internal
interface ConfigurationCacheStateStore {

    data class StateFile(val stateType: StateType, val file: File)

    fun assignSpoolFile(stateType: StateType): StateFile

    /**
     * Loads some value from zero or more state files.
     */
    fun <T : Any> useForStateLoad(action: (ConfigurationCacheRepository.Layout) -> T): T

    %outputs_4, %control_5 = tf_executor.island wraps "tf.If"(%outputs_2, %arg2, %arg3) {else_branch = @cond_false, is_stateless = false, then_branch = @cond_true} : (tensor<i1>, tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32> loc("StatefulIf")

# RUN: tf_tfl_translate -tf-input-arrays=a,b -tf-input-data-types=DT_FLOAT,DT_FLOAT -tf-input-shapes=: -tf-output-arrays=StatefulIf,StatelessIf %s -o - --output-mlir | FileCheck %s
node {
  name: "tf.Less"
  op: "Less"
  input: "a"
  input: "b"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  experimental_debug_info {
  }
}
node {
  name: "my_equal"
  op: "Equal"
  input: "a"
  input: "b"
  attr {

        _ * project1State.getMutableModel() >> project1
        _ * project2State.getMutableModel() >> project2
        projectStateRegistry = Mock(ProjectStateRegistry) {
            stateFor(projectId1) >> project1State
            stateFor(projectId2) >> project2State
        }
    }

    def "provides tasks from project dependencies"() {

        this.projectRegistry = projectRegistry;
    }

    @Override
    public String getUniqueName(Project project) {
        ProjectState projectState = projectRegistry.stateFor(project);
        String uniqueName = getDeduplicatedNames().get(projectState);
        if (uniqueName != null) {
            return uniqueName;
        }
        return project.getName();
    }