import org.gradle.internal.hash.HashCode;
import org.gradle.internal.resource.Resource;

import java.io.File;

/**
 * Represents a file backed local resource.
 */
public interface LocallyAvailableResource extends Resource {

    File getFile();

    HashCode getSha1();

    long getLastModified();

    long getContentLength();

        return fileAccessTracker;
    }

    @Override
    public LocallyAvailableResource move(ModuleComponentArtifactIdentifier key, File source) throws FileStoreException {
        return writableStore.move(key, source);
    }

    @Override
    public LocallyAvailableResource add(ModuleComponentArtifactIdentifier key, Action<File> addAction) throws FileStoreException {

        }
    }

    @Override
    public Set<? extends LocallyAvailableResource> search(String pattern) {
        if (!getBaseDir().exists()) {
            return Collections.emptySet();
        }

        final Set<LocallyAvailableResource> entries = new HashSet<LocallyAvailableResource>();
        findFiles(pattern).visit(new EmptyFileVisitor() {
            @Override

        return delegatingFileAccessTracker;
    }

    @Override
    public LocallyAvailableResource move(String key, File source) throws FileStoreException {
        return writableStore.move(key, source);
    }

    @Override
    public LocallyAvailableResource add(String key, Action<File> addAction) throws FileStoreException {
        return writableStore.add(key, addAction);
    }

        this.baseDir = baseDir;
        this.checksumService = checksumService;
    }

    @Override
    public LocallyAvailableResource move(K key, File source) {
        return markAccessed(delegate.move(toPath(key, getChecksum(source)), source));
    }

    @Override
    public Set<? extends LocallyAvailableResource> search(K key) {
        return delegate.search(toPath(key, "*"));
    }

import org.gradle.internal.resource.ExternalResourceName;
import org.gradle.internal.resource.local.FileStore;
import org.gradle.internal.resource.local.LocallyAvailableExternalResource;
import org.gradle.internal.resource.local.LocallyAvailableResource;
import org.gradle.internal.resource.local.LocallyAvailableResourceCandidates;

import javax.annotation.Nullable;
import java.io.File;
import java.io.IOException;

        return path.replaceAll("[^\\d\\w\\.\\*/]", "_");
    }

    @Override
    public LocallyAvailableResource add(String key, Action<File> addAction) {
        return delegate.add(normalizePath(key), addAction);
    }

    @Override
    public Set<? extends LocallyAvailableResource> search(String key) {
        return delegate.search(normalizeSearchPath(key));
    }

        0 * readStore.add(key, action)
    }

    def "searches in both read and write stores"() {
        setup:
        def r1 = Stub(LocallyAvailableResource)
        def r2 = Stub(LocallyAvailableResource)
        def r3 = Stub(LocallyAvailableResource)
        1 * writeStore.search(key) >> {
            [r1] as Set
        }
        1 * readStore.search(key) >> {
            [r2, r3] as Set
        }

import org.gradle.internal.component.external.model.ModuleComponentResolveMetadata;
import org.gradle.internal.component.external.model.MutableModuleComponentResolveMetadata;
import org.gradle.internal.resource.local.LocallyAvailableResource;
import org.gradle.internal.resource.local.PathKeyFileStore;
import org.gradle.internal.serialize.kryo.KryoBackedDecoder;
import org.gradle.internal.serialize.kryo.KryoBackedEncoder;

import java.io.FileInputStream;

    public UniquePathKeyFileStore(ChecksumService checksumService, File baseDir) {
        super(checksumService, baseDir);
    }

    @Override
    public LocallyAvailableResource move(String path, File source) {
        LocallyAvailableResource entry = super.move(path, source);
        if (source.exists()) {
            FileUtils.deleteQuietly(source);
        }
        return entry;
    }

    @Override