/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
    *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  package org.apache.commons.compress.compressors;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.security.AccessController;
  import java.security.PrivilegedAction;
  import java.util.Collections;
  import java.util.Locale;
  import java.util.ServiceLoader;
  import java.util.Set;
  import java.util.SortedMap;
  import java.util.TreeMap;
  
  import org.apache.commons.compress.compressors.brotli.BrotliCompressorInputStream;
  import org.apache.commons.compress.compressors.brotli.BrotliUtils;
  import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;
  import org.apache.commons.compress.compressors.bzip2.BZip2CompressorOutputStream;
  import org.apache.commons.compress.compressors.deflate.DeflateCompressorInputStream;
  import org.apache.commons.compress.compressors.deflate.DeflateCompressorOutputStream;
  import org.apache.commons.compress.compressors.deflate64.Deflate64CompressorInputStream;
  import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream;
  import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream;
  import org.apache.commons.compress.compressors.lz4.BlockLZ4CompressorInputStream;
  import org.apache.commons.compress.compressors.lz4.BlockLZ4CompressorOutputStream;
  import org.apache.commons.compress.compressors.lz4.FramedLZ4CompressorInputStream;
  import org.apache.commons.compress.compressors.lz4.FramedLZ4CompressorOutputStream;
  import org.apache.commons.compress.compressors.lzma.LZMACompressorInputStream;
  import org.apache.commons.compress.compressors.lzma.LZMACompressorOutputStream;
  import org.apache.commons.compress.compressors.lzma.LZMAUtils;
  import org.apache.commons.compress.compressors.pack200.Pack200CompressorInputStream;
  import org.apache.commons.compress.compressors.pack200.Pack200CompressorOutputStream;
  import org.apache.commons.compress.compressors.snappy.FramedSnappyCompressorInputStream;
  import org.apache.commons.compress.compressors.snappy.FramedSnappyCompressorOutputStream;
  import org.apache.commons.compress.compressors.snappy.SnappyCompressorInputStream;
  import org.apache.commons.compress.compressors.xz.XZCompressorInputStream;
  import org.apache.commons.compress.compressors.xz.XZCompressorOutputStream;
  import org.apache.commons.compress.compressors.xz.XZUtils;
  import org.apache.commons.compress.compressors.z.ZCompressorInputStream;
  import org.apache.commons.compress.compressors.zstandard.ZstdCompressorInputStream;
  import org.apache.commons.compress.compressors.zstandard.ZstdCompressorOutputStream;
  import org.apache.commons.compress.compressors.zstandard.ZstdUtils;
  import org.apache.commons.compress.utils.IOUtils;
  import org.apache.commons.compress.utils.Sets;
  
  /**
   * <p>
   * Factory to create Compressor[In|Out]putStreams from names. To add other implementations you should extend CompressorStreamFactory and override the
   * appropriate methods (and call their implementation from super of course).
   * </p>
   *
   * Example (Compressing a file):
   *
   * <pre>
   * final OutputStream out = Files.newOutputStream(output.toPath());
   * CompressorOutputStream cos = new CompressorStreamFactory().createCompressorOutputStream(CompressorStreamFactory.BZIP2, out);
   * IOUtils.copy(Files.newInputStream(input.toPath()), cos);
   * cos.close();
   * </pre>
   *
   * Example (Decompressing a file):
   *
   * <pre>
   * final InputStream is = Files.newInputStream(input.toPath());
   * CompressorInputStream in = new CompressorStreamFactory().createCompressorInputStream(CompressorStreamFactory.BZIP2, is);
   * IOUtils.copy(in, Files.newOutputStream(output.toPath()));
   * in.close();
   * </pre>
   *
   * @Immutable provided that the deprecated method setDecompressConcatenated is not used.
   * @ThreadSafe even if the deprecated method setDecompressConcatenated is used
   */
  public class CompressorStreamFactory implements CompressorStreamProvider {
  
      private static final CompressorStreamFactory SINGLETON = new CompressorStreamFactory();
  
      /**
       * Constant (value {@value}) used to identify the BROTLI compression algorithm.
       *
       * @since 1.14
       */
     public static final String BROTLI = "br";
 
     /**
      * Constant (value {@value}) used to identify the BZIP2 compression algorithm.
      *
      * @since 1.1
      */
     public static final String BZIP2 = "bzip2";
 
     /**
      * Constant (value {@value}) used to identify the GZIP compression algorithm.
      *
      * @since 1.1
      */
     public static final String GZIP = "gz";
 
     /**
      * Constant (value {@value}) used to identify the PACK200 compression algorithm.
      *
      * @since 1.3
      */
     public static final String PACK200 = "pack200";
 
     /**
      * Constant (value {@value}) used to identify the XZ compression method.
      *
      * @since 1.4
      */
     public static final String XZ = "xz";
 
     /**
      * Constant (value {@value}) used to identify the LZMA compression method.
      *
      * @since 1.6
      */
     public static final String LZMA = "lzma";
 
     /**
      * Constant (value {@value}) used to identify the "framed" Snappy compression method.
      *
      * @since 1.7
      */
     public static final String SNAPPY_FRAMED = "snappy-framed";
 
     /**
      * Constant (value {@value}) used to identify the "raw" Snappy compression method. Not supported as an output stream type.
      *
      * @since 1.7
      */
     public static final String SNAPPY_RAW = "snappy-raw";
 
     /**
      * Constant (value {@value}) used to identify the traditional UNIX compress method. Not supported as an output stream type.
      *
      * @since 1.7
      */
     public static final String Z = "z";
 
     /**
      * Constant (value {@value}) used to identify the Deflate compress method.
      *
      * @since 1.9
      */
     public static final String DEFLATE = "deflate";
 
     /**
      * Constant (value {@value}) used to identify the Deflate64 compress method.
      *
      * @since 1.16
      */
     public static final String DEFLATE64 = "deflate64";
 
     /**
      * Constant (value {@value}) used to identify the block LZ4 compression method.
      *
      * @since 1.14
      */
     public static final String LZ4_BLOCK = "lz4-block";
 
     /**
      * Constant (value {@value}) used to identify the frame LZ4 compression method.
      *
      * @since 1.14
      */
     public static final String LZ4_FRAMED = "lz4-framed";
 
     /**
      * Constant (value {@value}) used to identify the Zstandard compression algorithm. Not supported as an output stream type.
      *
      * @since 1.16
      */
     public static final String ZSTANDARD = "zstd";
 
     private static final String YOU_NEED_BROTLI_DEC = youNeed("Google Brotli Dec", "https://github.com/google/brotli/");
     private static final String YOU_NEED_XZ_JAVA = youNeed("XZ for Java", "https://tukaani.org/xz/java.html");
     private static final String YOU_NEED_ZSTD_JNI = youNeed("Zstd JNI", "https://github.com/luben/zstd-jni");
 
     private static final Set<String> ALL_NAMES = Sets.newHashSet(BZIP2, GZIP, PACK200, SNAPPY_FRAMED, Z, DEFLATE, XZ, LZMA, LZ4_FRAMED, ZSTANDARD);
 
     private static Iterable<CompressorStreamProvider> archiveStreamProviderIterable() {
         return ServiceLoader.load(CompressorStreamProvider.class, ClassLoader.getSystemClassLoader());
     }
 
     /**
      * Detects the type of compressor stream.
      *
      * @param inputStream input stream
      * @return type of compressor stream detected
      * @throws CompressorException      if no compressor stream type was detected or if something else went wrong
      * @throws IllegalArgumentException if stream is null or does not support mark
      *
      * @since 1.14
      */
     public static String detect(final InputStream inputStream) throws CompressorException {
         return detect(inputStream, ALL_NAMES);
     }
 
     /**
      * Detects the type of compressor stream while limiting the type to the provided set of compressor names.
      *
      * @param inputStream     input stream
      * @param compressorNames compressor names to limit autodetection
      * @return type of compressor stream detected
      * @throws CompressorException      if no compressor stream type was detected or if something else went wrong
      * @throws IllegalArgumentException if stream is null or does not support mark
      */
     static String detect(final InputStream inputStream, final Set<String> compressorNames) throws CompressorException {
         if (inputStream == null) {
             throw new IllegalArgumentException("Stream must not be null.");
         }
 
         if (compressorNames == null || compressorNames.isEmpty()) {
             throw new IllegalArgumentException("Compressor names cannot be null or empty");
         }
 
         if (!inputStream.markSupported()) {
             throw new IllegalArgumentException("Mark is not supported.");
         }
 
         final byte[] signature = new byte[12];
         inputStream.mark(signature.length);
         int signatureLength = -1;
         try {
             signatureLength = IOUtils.readFully(inputStream, signature);
             inputStream.reset();
         } catch (final IOException e) {
             throw new CompressorException("IOException while reading signature.", e);
         }
 
         if (compressorNames.contains(BZIP2) && BZip2CompressorInputStream.matches(signature, signatureLength)) {
             return BZIP2;
         }
 
         if (compressorNames.contains(GZIP) && GzipCompressorInputStream.matches(signature, signatureLength)) {
             return GZIP;
         }
 
         if (compressorNames.contains(PACK200) && Pack200CompressorInputStream.matches(signature, signatureLength)) {
             return PACK200;
         }
 
         if (compressorNames.contains(SNAPPY_FRAMED) && FramedSnappyCompressorInputStream.matches(signature, signatureLength)) {
             return SNAPPY_FRAMED;
         }
 
         if (compressorNames.contains(Z) && ZCompressorInputStream.matches(signature, signatureLength)) {
             return Z;
         }
 
         if (compressorNames.contains(DEFLATE) && DeflateCompressorInputStream.matches(signature, signatureLength)) {
             return DEFLATE;
         }
 
         if (compressorNames.contains(XZ) && XZUtils.matches(signature, signatureLength)) {
             return XZ;
         }
 
         if (compressorNames.contains(LZMA) && LZMAUtils.matches(signature, signatureLength)) {
             return LZMA;
         }
 
         if (compressorNames.contains(LZ4_FRAMED) && FramedLZ4CompressorInputStream.matches(signature, signatureLength)) {
             return LZ4_FRAMED;
         }
 
         if (compressorNames.contains(ZSTANDARD) && ZstdUtils.matches(signature, signatureLength)) {
             return ZSTANDARD;
         }
 
         throw new CompressorException("No Compressor found for the stream signature.");
     }
 
     /**
      * Constructs a new sorted map from input stream provider names to provider objects.
      *
      * <p>
      * The map returned by this method will have one entry for each provider for which support is available in the current Java virtual machine. If two or more
      * supported provider have the same name then the resulting map will contain just one of them; which one it will contain is not specified.
      * </p>
      *
      * <p>
      * The invocation of this method, and the subsequent use of the resulting map, may cause time-consuming disk or network I/O operations to occur. This method
      * is provided for applications that need to enumerate all of the available providers, for example to allow user provider selection.
      * </p>
      *
      * <p>
      * This method may return different results at different times if new providers are dynamically made available to the current Java virtual machine.
      * </p>
      *
      * @return An immutable, map from names to provider objects
      * @since 1.13
      */
     public static SortedMap<String, CompressorStreamProvider> findAvailableCompressorInputStreamProviders() {
         return AccessController.doPrivileged((PrivilegedAction<SortedMap<String, CompressorStreamProvider>>) () -> {
             final TreeMap<String, CompressorStreamProvider> map = new TreeMap<>();
             putAll(SINGLETON.getInputStreamCompressorNames(), SINGLETON, map);
             archiveStreamProviderIterable().forEach(provider -> putAll(provider.getInputStreamCompressorNames(), provider, map));
             return map;
         });
     }
 
     /**
      * Constructs a new sorted map from output stream provider names to provider objects.
      *
      * <p>
      * The map returned by this method will have one entry for each provider for which support is available in the current Java virtual machine. If two or more
      * supported provider have the same name then the resulting map will contain just one of them; which one it will contain is not specified.
      * </p>
      *
      * <p>
      * The invocation of this method, and the subsequent use of the resulting map, may cause time-consuming disk or network I/O operations to occur. This method
      * is provided for applications that need to enumerate all of the available providers, for example to allow user provider selection.
      * </p>
      *
      * <p>
      * This method may return different results at different times if new providers are dynamically made available to the current Java virtual machine.
      * </p>
      *
      * @return An immutable, map from names to provider objects
      * @since 1.13
      */
     public static SortedMap<String, CompressorStreamProvider> findAvailableCompressorOutputStreamProviders() {
         return AccessController.doPrivileged((PrivilegedAction<SortedMap<String, CompressorStreamProvider>>) () -> {
             final TreeMap<String, CompressorStreamProvider> map = new TreeMap<>();
             putAll(SINGLETON.getOutputStreamCompressorNames(), SINGLETON, map);
             archiveStreamProviderIterable().forEach(provider -> putAll(provider.getOutputStreamCompressorNames(), provider, map));
             return map;
         });
     }
 
     public static String getBrotli() {
         return BROTLI;
     }
 
     public static String getBzip2() {
         return BZIP2;
     }
 
     public static String getDeflate() {
         return DEFLATE;
     }
 
     /**
      * @since 1.16
      * @return the constant {@link #DEFLATE64}
      */
     public static String getDeflate64() {
         return DEFLATE64;
     }
 
     public static String getGzip() {
         return GZIP;
     }
 
     public static String getLZ4Block() {
         return LZ4_BLOCK;
     }
 
     public static String getLZ4Framed() {
         return LZ4_FRAMED;
     }
 
     public static String getLzma() {
         return LZMA;
     }
 
     public static String getPack200() {
         return PACK200;
     }
 
     public static CompressorStreamFactory getSingleton() {
         return SINGLETON;
     }
 
     public static String getSnappyFramed() {
         return SNAPPY_FRAMED;
     }
 
     public static String getSnappyRaw() {
         return SNAPPY_RAW;
     }
 
     public static String getXz() {
         return XZ;
     }
 
     public static String getZ() {
         return Z;
     }
 
     public static String getZstandard() {
         return ZSTANDARD;
     }
 
     static void putAll(final Set<String> names, final CompressorStreamProvider provider, final TreeMap<String, CompressorStreamProvider> map) {
         names.forEach(name -> map.put(toKey(name), provider));
     }
 
     private static String toKey(final String name) {
         return name.toUpperCase(Locale.ROOT);
     }
 
     private static String youNeed(final String name, final String url) {
         return " In addition to Apache Commons Compress you need the " + name + " library - see " + url;
     }
 
     /**
      * If true, decompress until the end of the input. If false, stop after the first stream and leave the input position to point to the next byte after the
      * stream
      */
     private final Boolean decompressUntilEOF;
     // This is Boolean so setDecompressConcatenated can determine whether it has
     // been set by the ctor
     // once the setDecompressConcatenated method has been removed, it can revert
     // to boolean
 
     private SortedMap<String, CompressorStreamProvider> compressorInputStreamProviders;
 
     private SortedMap<String, CompressorStreamProvider> compressorOutputStreamProviders;
 
     /**
      * If true, decompress until the end of the input. If false, stop after the first stream and leave the input position to point to the next byte after the
      * stream
      */
     private volatile boolean decompressConcatenated;
 
     private final int memoryLimitInKb;
 
     /**
      * Constructs an instance with the decompress Concatenated option set to false.
      */
     public CompressorStreamFactory() {
         this.decompressUntilEOF = null;
         this.memoryLimitInKb = -1;
     }
 
     /**
      * Constructs an instance with the provided decompress Concatenated option.
      *
      * @param decompressUntilEOF if true, decompress until the end of the input; if false, stop after the first stream and leave the input position to point to
      *                           the next byte after the stream. This setting applies to the gzip, bzip2 and XZ formats only.
      * @since 1.10
      */
     public CompressorStreamFactory(final boolean decompressUntilEOF) {
         this(decompressUntilEOF, -1);
     }
 
     /**
      * Constructs an instance with the provided decompress Concatenated option.
      *
      * @param decompressUntilEOF if true, decompress until the end of the input; if false, stop after the first stream and leave the input position to point to
      *                           the next byte after the stream. This setting applies to the gzip, bzip2 and XZ formats only.
      * @param memoryLimitInKb    Some streams require allocation of potentially significant byte arrays/tables, and they can offer checks to prevent OOMs on
      *                           corrupt files. Set the maximum allowed memory allocation in KBs.
      *
      * @since 1.14
      */
     public CompressorStreamFactory(final boolean decompressUntilEOF, final int memoryLimitInKb) {
         this.decompressUntilEOF = decompressUntilEOF;
         // Also copy to existing variable so can continue to use that as the
         // current value
         this.decompressConcatenated = decompressUntilEOF;
         this.memoryLimitInKb = memoryLimitInKb;
     }
 
     /**
      * Creates a compressor input stream from an input stream, auto-detecting the compressor type from the first few bytes of the stream. The InputStream must
      * support marks, like BufferedInputStream.
      *
      * @param in the input stream
      * @return the compressor input stream
      * @throws CompressorException      if the compressor name is not known
      * @throws IllegalArgumentException if the stream is null or does not support mark
      * @since 1.1
      */
     public CompressorInputStream createCompressorInputStream(final InputStream in) throws CompressorException {
         return createCompressorInputStream(detect(in), in);
     }
 
     /**
      * Creates a compressor input stream from an input stream, auto-detecting the compressor type from the first few bytes of the stream while limiting the
      * detected type to the provided set of compressor names. The InputStream must support marks, like BufferedInputStream.
      *
      * @param in              the input stream
      * @param compressorNames compressor names to limit autodetection
      * @return the compressor input stream
      * @throws CompressorException      if the autodetected compressor is not in the provided set of compressor names
      * @throws IllegalArgumentException if the stream is null or does not support mark
      * @since 1.25.0
      */
     public CompressorInputStream createCompressorInputStream(final InputStream in, final Set<String> compressorNames) throws CompressorException {
         return createCompressorInputStream(detect(in, compressorNames), in);
     }
 
     /**
      * Creates a compressor input stream from a compressor name and an input stream.
      *
      * @param name of the compressor, i.e. {@value #GZIP}, {@value #BZIP2}, {@value #XZ}, {@value #LZMA}, {@value #PACK200}, {@value #SNAPPY_RAW},
      *             {@value #SNAPPY_FRAMED}, {@value #Z}, {@value #LZ4_BLOCK}, {@value #LZ4_FRAMED}, {@value #ZSTANDARD}, {@value #DEFLATE64} or
      *             {@value #DEFLATE}
      * @param in   the input stream
      * @return compressor input stream
      * @throws CompressorException      if the compressor name is not known or not available, or if there's an IOException or MemoryLimitException thrown during
      *                                  initialization
      * @throws IllegalArgumentException if the name or input stream is null
      */
     public CompressorInputStream createCompressorInputStream(final String name, final InputStream in) throws CompressorException {
         return createCompressorInputStream(name, in, decompressConcatenated);
     }
 
     @Override
     public CompressorInputStream createCompressorInputStream(final String name, final InputStream in, final boolean actualDecompressConcatenated)
             throws CompressorException {
         if (name == null || in == null) {
             throw new IllegalArgumentException("Compressor name and stream must not be null.");
         }
 
         try {
 
             if (GZIP.equalsIgnoreCase(name)) {
                 return new GzipCompressorInputStream(in, actualDecompressConcatenated);
             }
 
             if (BZIP2.equalsIgnoreCase(name)) {
                 return new BZip2CompressorInputStream(in, actualDecompressConcatenated);
             }
 
             if (BROTLI.equalsIgnoreCase(name)) {
                 if (!BrotliUtils.isBrotliCompressionAvailable()) {
                     throw new CompressorException("Brotli compression is not available." + YOU_NEED_BROTLI_DEC);
                 }
                 return new BrotliCompressorInputStream(in);
             }
 
             if (XZ.equalsIgnoreCase(name)) {
                 if (!XZUtils.isXZCompressionAvailable()) {
                     throw new CompressorException("XZ compression is not available." + YOU_NEED_XZ_JAVA);
                 }
                 return new XZCompressorInputStream(in, actualDecompressConcatenated, memoryLimitInKb);
             }
 
             if (ZSTANDARD.equalsIgnoreCase(name)) {
                 if (!ZstdUtils.isZstdCompressionAvailable()) {
                     throw new CompressorException("Zstandard compression is not available." + YOU_NEED_ZSTD_JNI);
                 }
                 return new ZstdCompressorInputStream(in);
             }
 
             if (LZMA.equalsIgnoreCase(name)) {
                 if (!LZMAUtils.isLZMACompressionAvailable()) {
                     throw new CompressorException("LZMA compression is not available" + YOU_NEED_XZ_JAVA);
                 }
                 return new LZMACompressorInputStream(in, memoryLimitInKb);
             }
 
             if (PACK200.equalsIgnoreCase(name)) {
                 return new Pack200CompressorInputStream(in);
             }
 
             if (SNAPPY_RAW.equalsIgnoreCase(name)) {
                 return new SnappyCompressorInputStream(in);
             }
 
             if (SNAPPY_FRAMED.equalsIgnoreCase(name)) {
                 return new FramedSnappyCompressorInputStream(in);
             }
 
             if (Z.equalsIgnoreCase(name)) {
                 return new ZCompressorInputStream(in, memoryLimitInKb);
             }
 
             if (DEFLATE.equalsIgnoreCase(name)) {
                 return new DeflateCompressorInputStream(in);
             }
 
             if (DEFLATE64.equalsIgnoreCase(name)) {
                 return new Deflate64CompressorInputStream(in);
             }
 
             if (LZ4_BLOCK.equalsIgnoreCase(name)) {
                 return new BlockLZ4CompressorInputStream(in);
             }
 
             if (LZ4_FRAMED.equalsIgnoreCase(name)) {
                 return new FramedLZ4CompressorInputStream(in, actualDecompressConcatenated);
             }
 
         } catch (final IOException e) {
             throw new CompressorException("Could not create CompressorInputStream.", e);
         }
         final CompressorStreamProvider compressorStreamProvider = getCompressorInputStreamProviders().get(toKey(name));
         if (compressorStreamProvider != null) {
             return compressorStreamProvider.createCompressorInputStream(name, in, actualDecompressConcatenated);
         }
 
         throw new CompressorException("Compressor: " + name + " not found.");
     }
 
     /**
      * Creates a compressor output stream from a compressor name and an output stream.
      *
      * @param name the compressor name, i.e. {@value #GZIP}, {@value #BZIP2}, {@value #XZ}, {@value #PACK200}, {@value #SNAPPY_FRAMED}, {@value #LZ4_BLOCK},
      *             {@value #LZ4_FRAMED}, {@value #ZSTANDARD} or {@value #DEFLATE}
      * @param out  the output stream
      * @return the compressor output stream
      * @throws CompressorException      if the archiver name is not known
      * @throws IllegalArgumentException if the archiver name or stream is null
      */
     @Override
     public CompressorOutputStream<?> createCompressorOutputStream(final String name, final OutputStream out) throws CompressorException {
         if (name == null || out == null) {
             throw new IllegalArgumentException("Compressor name and stream must not be null.");
         }
 
         try {
 
             if (GZIP.equalsIgnoreCase(name)) {
                 return new GzipCompressorOutputStream(out);
             }
 
             if (BZIP2.equalsIgnoreCase(name)) {
                 return new BZip2CompressorOutputStream(out);
             }
 
             if (XZ.equalsIgnoreCase(name)) {
                 return new XZCompressorOutputStream(out);
             }
 
             if (PACK200.equalsIgnoreCase(name)) {
                 return new Pack200CompressorOutputStream(out);
             }
 
             if (LZMA.equalsIgnoreCase(name)) {
                 return new LZMACompressorOutputStream(out);
             }
 
             if (DEFLATE.equalsIgnoreCase(name)) {
                 return new DeflateCompressorOutputStream(out);
             }
 
             if (SNAPPY_FRAMED.equalsIgnoreCase(name)) {
                 return new FramedSnappyCompressorOutputStream(out);
             }
 
             if (LZ4_BLOCK.equalsIgnoreCase(name)) {
                 return new BlockLZ4CompressorOutputStream(out);
             }
 
             if (LZ4_FRAMED.equalsIgnoreCase(name)) {
                 return new FramedLZ4CompressorOutputStream(out);
             }
 
             if (ZSTANDARD.equalsIgnoreCase(name)) {
                 return new ZstdCompressorOutputStream(out);
             }
         } catch (final IOException e) {
             throw new CompressorException("Could not create CompressorOutputStream", e);
         }
         final CompressorStreamProvider compressorStreamProvider = getCompressorOutputStreamProviders().get(toKey(name));
         if (compressorStreamProvider != null) {
             return compressorStreamProvider.createCompressorOutputStream(name, out);
         }
         throw new CompressorException("Compressor: " + name + " not found.");
     }
 
     public SortedMap<String, CompressorStreamProvider> getCompressorInputStreamProviders() {
         if (compressorInputStreamProviders == null) {
             compressorInputStreamProviders = Collections.unmodifiableSortedMap(findAvailableCompressorInputStreamProviders());
         }
         return compressorInputStreamProviders;
     }
 
     public SortedMap<String, CompressorStreamProvider> getCompressorOutputStreamProviders() {
         if (compressorOutputStreamProviders == null) {
             compressorOutputStreamProviders = Collections.unmodifiableSortedMap(findAvailableCompressorOutputStreamProviders());
         }
         return compressorOutputStreamProviders;
     }
 
     /** For tests. */
     boolean getDecompressConcatenated() {
         return decompressConcatenated;
     }
 
     public Boolean getDecompressUntilEOF() {
         return decompressUntilEOF;
     }
 
     @Override
     public Set<String> getInputStreamCompressorNames() {
         return Sets.newHashSet(GZIP, BROTLI, BZIP2, XZ, LZMA, PACK200, DEFLATE, SNAPPY_RAW, SNAPPY_FRAMED, Z, LZ4_BLOCK, LZ4_FRAMED, ZSTANDARD, DEFLATE64);
     }
 
     @Override
     public Set<String> getOutputStreamCompressorNames() {
         return Sets.newHashSet(GZIP, BZIP2, XZ, LZMA, PACK200, DEFLATE, SNAPPY_FRAMED, LZ4_BLOCK, LZ4_FRAMED, ZSTANDARD);
     }
 
     /**
      * Sets whether to decompress the full input or only the first stream in formats supporting multiple concatenated input streams.
      *
      * <p>
      * This setting applies to the gzip, bzip2 and XZ formats only.
      * </p>
      *
      * @param decompressConcatenated if true, decompress until the end of the input; if false, stop after the first stream and leave the input position to point
      *                               to the next byte after the stream
      * @since 1.5
      * @deprecated 1.10 use the {@link #CompressorStreamFactory(boolean)} constructor instead
      * @throws IllegalStateException if the constructor {@link #CompressorStreamFactory(boolean)} was used to create the factory
      */
     @Deprecated
     public void setDecompressConcatenated(final boolean decompressConcatenated) {
         if (this.decompressUntilEOF != null) {
             throw new IllegalStateException("Cannot override the setting defined by the constructor");
         }
         this.decompressConcatenated = decompressConcatenated;
     }
 
 }