*/

package org.gradle.api.resources.internal;

import org.gradle.api.resources.ReadableResource;
import org.gradle.internal.resource.Resource;

import java.io.File;

public interface ReadableResourceInternal extends ReadableResource, Resource {
    File getBackingFile();

        this.fileResolver = fileResolver;
        this.fileSystem = fileSystem;
    }

    @Override
    public ReadableResourceInternal resolveResource(Object path) {
        if (path instanceof ReadableResourceInternal) {
            return (ReadableResourceInternal) path;
        }
        return new LocalResourceAdapter(new LocalFileStandInExternalResource(fileResolver.resolve(path), fileSystem));
    }

        this.textResourceFactory = textResourceFactory;
    }

    @Override
    public ReadableResourceInternal gzip(Object path) {
        return new GzipArchiver(resourceResolver.resolveResource(path));
    }

    @Override
    public ReadableResourceInternal bzip2(Object path) {
        return new Bzip2Archiver(resourceResolver.resolveResource(path));
    }

    @Override

import org.gradle.api.resources.internal.ReadableResourceInternal;

import java.io.File;
import java.io.InputStream;
import java.net.URI;

abstract class AbstractArchiver implements CompressedReadableResource {
    protected final ReadableResourceInternal resource;
    protected final URI uri;

    public AbstractArchiver(ReadableResourceInternal resource) {
        assert resource != null;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.InputStream;
import java.net.URI;

/**
 * Adapts a {@link LocalBinaryResource} to a {@link ReadableResourceInternal}.
 */
public class LocalResourceAdapter implements ReadableResourceInternal {
    private final LocalBinaryResource resource;

    public LocalResourceAdapter(LocalBinaryResource resource) {
        this.resource = resource;
    }

    private final Provider<ReadableResourceInternal> resource;
    private final Chmod chmod;
    private final DirectoryFileTreeFactory directoryFileTreeFactory;
    private final FileHasher fileHasher;
    private final TemporaryFileProvider temporaryExtractionDir;

    public TarFileTree(
        Provider<File> tarFileProvider,
        Provider<ReadableResourceInternal> resource,
        Chmod chmod,

    public FileTreeInternal tarTree(Object tarPath) {
        Provider<File> fileProvider = asFileProvider(tarPath);
        Provider<ReadableResourceInternal> resource = providers.provider(() -> {
            if (tarPath instanceof ReadableResourceInternal) {
                return (ReadableResourceInternal) tarPath;
            } else {
                File tarFile = file(tarPath);

import org.gradle.api.resources.internal.ReadableResourceInternal;
import org.gradle.api.tasks.bundling.Compression;

import java.io.File;
import java.io.InputStream;
import java.net.URI;

public class MaybeCompressedFileResource implements ReadableResourceInternal {

    private final ReadableResourceInternal resource;

    public MaybeCompressedFileResource(ReadableResourceInternal resource) {

 */

package org.gradle.api.internal.file.archive.compression;

import org.apache.tools.bzip2.CBZip2InputStream;
import org.apache.tools.bzip2.CBZip2OutputStream;
import org.gradle.api.resources.internal.ReadableResourceInternal;
import org.gradle.internal.IoActions;
import org.gradle.internal.resource.ResourceExceptions;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

 * limitations under the License.
 */

package org.gradle.api.internal.file.archive.compression;

import org.gradle.api.resources.internal.ReadableResourceInternal;

public interface CompressedReadableResource extends ReadableResourceInternal {