}
	return err
}

var (
	compressors   sync.Map // map[uint16]Compressor
	decompressors sync.Map // map[uint16]Decompressor
)

func init() {
	compressors.Store(Store, Compressor(func(w io.Writer) (io.WriteCloser, error) { return &nopCloser{w}, nil }))
	compressors.Store(Deflate, Compressor(func(w io.Writer) (io.WriteCloser, error) { return newFlateWriter(w), nil }))

	decompressors.Store(Store, Decompressor(io.NopCloser))

}

// RegisterCompressor registers or overrides a custom compressor for a specific
// method ID. If a compressor for a given method is not found, [Writer] will
// default to looking up the compressor at the package level.
func (w *Writer) RegisterCompressor(method uint16, comp Compressor) {
	if w.compressors == nil {
		w.compressors = make(map[uint16]Compressor)
	}
	w.compressors[method] = comp
}

import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;
import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream;
import org.elasticsearch.gradle.internal.test.GradleIntegrationTestCase;
import org.gradle.api.GradleException;

 */

package org.elasticsearch.gradle.internal

import org.apache.commons.compress.archivers.tar.TarArchiveEntry
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream
import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream
import org.apache.tools.zip.ZipEntry
import org.apache.tools.zip.ZipFile
import org.elasticsearch.gradle.fixtures.AbstractGradleFuncTest
import org.gradle.testkit.runner.BuildResult

S'il n'y a pas `gzip` dans l'en-tête, elle n'essaiera pas de décompresser le corps.

De cette manière, la même classe de route peut gérer des requêtes gzip compressées ou non compressées.

{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[9:16] *}

### Créer une classe `GzipRoute` personnalisée { #create-a-custom-gziproute-class }

        final ArchiveOutputStreamFactory compressor;
        switch (getCompression()) {
            case BZIP2:
                compressor = Bzip2Archiver.getCompressor();
                break;
            case GZIP:
                compressor = GzipArchiver.getCompressor();
                break;
            default:
                compressor = new SimpleCompressor();
                break;
        }

}

func ExampleWriter_RegisterCompressor() {
	// Override the default Deflate compressor with a higher compression level.

	// Create a buffer to write our archive to.
	buf := new(bytes.Buffer)

	// Create a new zip archive.
	w := zip.NewWriter(buf)

	// Register a custom Deflate compressor.
	w.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {

		return sealETag(key, md5sumcurr)
	}
	return fn
}

// compressOpts are the options for writing compressed data.
var compressOpts []s2.WriterOption

func init() {
	if runtime.GOARCH == "amd64" {
		// On amd64 we have assembly and can use stronger compression.
		compressOpts = append(compressOpts, s2.WriterBetterCompression())
	}
}

    /**
     * Compresses data using the specified algorithm.
     *
     * @param data the data to compress
     * @param algorithm the compression algorithm to use
     * @return the compressed data
     * @throws CIFSException if compression fails
     */
    byte[] compress(byte[] data, int algorithm) throws CIFSException;

    /**
     * Compresses data using the specified algorithm with offset and length.

        case COMPRESSION_PATTERN_V1:
            return "Pattern_V1";
        default:
            return "Unknown(0x" + Integer.toHexString(algorithm) + ")";
        }
    }

    /**
     * Compresses data using LZ77 algorithm (implemented using Java's Deflater).
     */
    private byte[] compressLZ77(byte[] data, int offset, int length) throws CIFSException {
        try {