* limitations under the License.
 */

package org.gradle.caching.internal.tasks;

import java.io.IOException;
import java.util.List;

interface Packer {
    void pack(List<DataSource> inputs, DataTarget output) throws IOException;
    void unpack(DataSource input, DataTargetFactory targetFactory) throws IOException;

        return source;
    }

    @Benchmark
    public void pack() throws IOException {
        String packerName = getPackerName();
        String accessorName = getAccessorName();
        Packer packer = PACKERS.get(packerName);
        DataAccessor accessor = ACCESSORS.get(accessorName);
        packer.pack(inputs, accessor.createTarget("pack-" + packerName, Level.Iteration));
    }

    @Benchmark

import java.io.OutputStream;
import java.util.List;

public class SnappyDainPacker implements Packer {
    private final Packer delegate;

    public SnappyDainPacker(Packer delegate) {
        this.delegate = delegate;
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        delegate.pack(inputs, new DelegatingDataTarget(output) {
            @Override

        TemporaryFileProvider temporaryFileProvider,
        BuildCacheEntryPacker packer
    ) {
        super(
            startParameter,
            buildOperationRunner,
            originMetadataFactory,
            stringInterner
        );
        this.temporaryFileProvider = temporaryFileProvider;
        this.packer = packer;
        this.buildOperationProgressEmitter = buildOperationProgressEmitter;
    }

import java.io.OutputStream;
import java.util.List;

public class SnappyCommonsPacker implements Packer {
    private final Packer delegate;

    public SnappyCommonsPacker(Packer delegate) {
        this.delegate = delegate;
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        delegate.pack(inputs, new DelegatingDataTarget(output) {
            @Override

public class TaskOutputPackagingTarBenchmark extends AbstractTaskOutputPackagingBenchmark {
    @Param({"tar", "tar.commons", "tar.jtar"})
    String packer;

    @Param({"direct", "buffered"})
    String accessor;

    @Override
    protected String getPackerName() {
        return packer;
    }

    @Override
    protected String getAccessorName() {
        return accessor;
    }

import java.util.zip.GZIPOutputStream;

public class GzipPacker implements Packer {
    private final Packer delegate;

    public GzipPacker(Packer delegate) {
        this.delegate = delegate;
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        delegate.pack(inputs, new DelegatingDataTarget(output) {
            @Override

            }
            return [(treeDef.name): result]
        }
        packer.pack(entity(treeDefs), snapshots, output, writeOrigin)
    }

    def unpack(InputStream input, OriginReader readOrigin = this.readOrigin, TreeDefinition... treeDefs) {
        packer.unpack(entity(treeDefs), input, readOrigin)
    }

    def entity(TreeDefinition... treeDefs) {
        Stub(CacheableEntity) {

import java.io.OutputStream;
import java.util.List;

public class SnappyPacker implements Packer {
    private final Packer delegate;

    public SnappyPacker(Packer delegate) {
        this.delegate = delegate;
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        delegate.pack(inputs, new DelegatingDataTarget(output) {
            @Override

        private final BuildOperationRunner buildOperationRunner;
        private final BuildCacheEntryPacker packer;
        private final OriginMetadataFactory originMetadataFactory;
        private final Interner<String> stringInterner;

        PackOperationExecutor(BuildOperationRunner buildOperationRunner, BuildCacheEntryPacker packer, OriginMetadataFactory originMetadataFactory, Interner<String> stringInterner) {