def storeOp = cacheOperations.getOnlyLocalStoreOperationForTask(":t")

        def cacheKey = localMissLoadOp.details.cacheKey
        cacheKey != null
        def archiveSize = localCache.getCacheEntry(cacheKey.toString()).bytes.length

        !localMissLoadOp.result.hit

        packOp.details.cacheKey == cacheKey

        packOp.result.archiveSize == archiveSize
        packOp.result.archiveEntryCount == 5

                return false;
            }
            CacheKey cacheKey = (CacheKey) o;
            return Objects.equal(backingStateType, cacheKey.backingStateType)
                && Objects.equal(schema, cacheKey.schema)
                && Objects.equal(structBindings.getDelegateSchema(), cacheKey.structBindings.getDelegateSchema());
        }

        @Override
        public int hashCode() {

        assertNotSame(lr1, lr2);
        assertNotSame(rr1, rr2);

        DefaultMavenMetadataCache.CacheKey k1 =
                new DefaultMavenMetadataCache.CacheKey(a1, false, lr1, Collections.singletonList(rr1));
        DefaultMavenMetadataCache.CacheKey k2 =
                new DefaultMavenMetadataCache.CacheKey(a2, false, lr2, Collections.singletonList(rr2));

        assertEquals(k1.hashCode(), k2.hashCode());
    }

    private val fileAccessTimeJournal: FileAccessTimeJournal,
    private val fileSystem: FileSystem
) : Stoppable {
    fun forKey(cacheKey: String): ConfigurationCacheStateStore {
        return StoreImpl(cache.baseDirFor(cacheKey))
    }

    abstract class Layout {
        abstract fun fileForRead(stateType: StateType): ConfigurationCacheStateFile

        buildCacheController.store(
            cacheKey,
            sandboxEntity,
            ImmutableMap.of("output", producedOutputSnapshot),
            Duration.ofSeconds(10));

        // Load the entity from the cache
        BuildCacheLoadResult loadResult = buildCacheController.load(cacheKey, targetEntity)
            .orElseThrow(() -> new RuntimeException("Should have been a hit"));

 */
@ServiceScope(Scope.Gradle.class)
public interface BuildCacheController extends Closeable {

    boolean isEnabled();

    Optional<BuildCacheLoadResult> load(BuildCacheKey cacheKey, CacheableEntity cacheableEntity);

    void store(BuildCacheKey cacheKey, CacheableEntity entity, Map<String, FileSystemSnapshot> snapshots, Duration executionTime);

		ce.resourceVersionByResource[key.resourceName] = key.resourceVersion
	}
	return needChecksumUpdate
}

// addEntry adds a wasmModule to cache with cacheKey, writes the module to the local file system,
// and returns the created entry.
func (c *LocalFileCache) addEntry(key cacheKey, wasmModule []byte) (*cacheEntry, error) {
	c.mux.Lock()
	defer c.mux.Unlock()
	needChecksumUpdate := c.updateChecksum(key)

        public Optional<BuildCacheLoadResult> load(BuildCacheKey cacheKey, CacheableEntity cacheableEntity) {
            return getDelegate().load(cacheKey, cacheableEntity);
        }

        @Override
        public void store(BuildCacheKey cacheKey, CacheableEntity entity, Map<String, FileSystemSnapshot> snapshots, Duration executionTime) {
            getDelegate().store(cacheKey, entity, snapshots, executionTime);
        }

	if err != nil {
		// This could be expected if object got deleted
		c.logger.V(5).Info("Restore object", "description", c.description, "cacheKey", objName, "err", err)
	} else {
		objInfo.latestObj = objInfo.apiObj
		c.logger.V(4).Info("Restored object", "description", c.description, "cacheKey", objName)
	}

                recordArtifacts = pluginArtifactsCache.put(cacheKey, artifacts);
            } catch (PluginResolutionException e) {
                pluginArtifactsCache.put(cacheKey, e);
                pluginArtifactsCache.register(project, cacheKey, recordArtifacts);
                throw new PluginManagerException(plugin, e.getMessage(), e);
            }
        }