import javax.annotation.Nullable;
import java.util.Date;

/**
 * A record of some kind of external resource that has been cached locally (typically into the filestore).
 */
public interface CachedExternalResource extends CachedItem {

    /**
     * Always the actual content length of the cached file, not the external source.
     *
     * @return The content length of the cached file.
     */

    }

    @Override
    public void storeMissing(String key) {
        writableCache.storeMissing(key);
    }

    @Nullable
    @Override
    public CachedExternalResource lookup(String key) {
        CachedExternalResource lookup = writableCache.lookup(key);
        if (lookup != null) {
            return lookup;
        }
        return readOnlyCache.lookup(key);
    }

    @Override

import java.io.IOException;
import java.io.Serializable;
import java.net.URI;
import java.nio.file.Path;

public class DefaultCachedExternalResourceIndex<K extends Serializable> extends AbstractCachedIndex<K, CachedExternalResource> implements CachedExternalResourceIndex<K> {
    private final BuildCommencedTimeProvider timeProvider;

    /**
     * Lookup a cached resolution.
     *
     * The {@link CachedExternalResource#getCachedFile()} is guaranteed
     * to exist at the time that the entry is returned from this method.
     *
     * @param key The key to search the index for
     * @return The cached artifact resolution if one exists, otherwise null.
     */
    @Nullable
    CachedExternalResource lookup(K key);

    /**

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.modulecache.artifacts;

import org.gradle.internal.hash.HashCode;
import org.gradle.internal.resource.cached.CachedExternalResource;

import javax.annotation.Nullable;
import java.io.File;
import java.util.List;

public interface ModuleArtifactCache {
    /**
     * Adds a resolution to the index.
     *

import org.gradle.internal.resource.ExternalResourceName
import org.gradle.internal.resource.ExternalResourceReadResult
import org.gradle.internal.resource.ExternalResourceRepository
import org.gradle.internal.resource.cached.CachedExternalResource
import org.gradle.internal.resource.cached.CachedExternalResourceIndex
import org.gradle.internal.resource.local.DefaultLocallyAvailableResource
import org.gradle.internal.resource.local.FileResourceRepository

import org.gradle.internal.resource.ExternalResourceName;
import org.gradle.internal.resource.ExternalResourceReadResult;
import org.gradle.internal.resource.ExternalResourceRepository;
import org.gradle.internal.resource.cached.CachedExternalResource;
import org.gradle.internal.resource.cached.CachedExternalResourceIndex;
import org.gradle.internal.resource.local.FileResourceRepository;
import org.gradle.internal.resource.local.LocallyAvailableExternalResource;

import org.gradle.internal.resource.metadata.ExternalResourceMetaData;

import java.io.File;
import java.io.Serializable;
import java.util.Date;

public class DefaultCachedExternalResource implements CachedExternalResource, Serializable {
    private final File cachedFile;
    private final long cachedAt;
    private final ExternalResourceMetaData externalResourceMetaData;

        given:
        def serializer = new DefaultCachedExternalResourceIndex.CachedExternalResourceSerializer(commonPath)
        def encoder = Mock(Encoder)
        def value = Mock(CachedExternalResource)
        def fileName = "file.txt"

        when:
        serializer.write(encoder, value)

        then:
        _ * value.getCachedFile() >> commonPath.resolve(fileName).toFile()

        1 * writeIndex.lookup("key") >> null
        1 * readIndex.lookup("key")

        when:
        twoStageIndex.lookup("other")

        then:
        1 * writeIndex.lookup("other") >> Stub(CachedExternalResource)
        0 * readIndex._
    }

    def "clearing delegates to the writable cache"() {
        when:
        twoStageIndex.clear("key")

        then:
        1 * writeIndex.clear("key")