Beispiel #1
0
        /// <summary>
        /// Opens a Reader for Non-seeking usage
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public static IReader Open(Stream stream, Options options = Options.KeepStreamsOpen)
        {
            stream.CheckNotNull("stream");

            RewindableStream rewindableStream = new RewindableStream(stream);
            rewindableStream.StartRecording();
            if (ZipArchive.IsZipFile(rewindableStream, null))
            {
                rewindableStream.Rewind(true);
                return ZipReader.Open(rewindableStream, null, options);
            }
            rewindableStream.Rewind(false);
            if (GZipArchive.IsGZipFile(rewindableStream))
            {
                rewindableStream.Rewind(false);
                GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
                if (TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    return new TarReader(rewindableStream, CompressionType.GZip, options);
                }
                rewindableStream.Rewind(true);
                return GZipReader.Open(rewindableStream, options);
            }

            rewindableStream.Rewind(false);
            if (BZip2Stream.IsBZip2(rewindableStream))
            {
                rewindableStream.Rewind(false);
                BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, false);
                if (TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    return new TarReader(rewindableStream, CompressionType.BZip2, options);
                }
            }

            rewindableStream.Rewind(false);
            if (TarArchive.IsTarFile(rewindableStream))
            {
                rewindableStream.Rewind(true);
                return TarReader.Open(rewindableStream, options);
            }
            rewindableStream.Rewind(false);
            if (RarArchive.IsRarFile(rewindableStream, options))
            {
                rewindableStream.Rewind(true);
                return RarReader.Open(rewindableStream, options);
            }

            throw new InvalidOperationException("Cannot determine compressed stream type.");
        }
Beispiel #2
0
        /// <summary>
        /// Opens an Archive for random access
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public static IArchive Open(Stream stream, Options options = Options.KeepStreamsOpen)
        {
            stream.CheckNotNull("stream");
            if (!stream.CanRead || !stream.CanSeek)
            {
                throw new ArgumentException("Stream should be readable and seekable");
            }

            if (ZipArchive.IsZipFile(stream, null))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return ZipArchive.Open(stream, options, null);
            }
#if RAR
            stream.Seek(0, SeekOrigin.Begin);
            if (RarArchive.IsRarFile(stream, Options.LookForHeader | Options.KeepStreamsOpen))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return RarArchive.Open(stream, options);
            }
#endif
#if TAR
            stream.Seek(0, SeekOrigin.Begin);
            if (TarArchive.IsTarFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return TarArchive.Open(stream, options);
            }
#endif
#if SEVENZIP
            stream.Seek(0, SeekOrigin.Begin);
            if (SevenZipArchive.IsSevenZipFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return SevenZipArchive.Open(stream, options);
            }
#endif
#if GZIP
            stream.Seek(0, SeekOrigin.Begin);
            if (GZipArchive.IsGZipFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return GZipArchive.Open(stream, options);
            }
#endif
            throw new InvalidOperationException("Cannot determine compressed stream type.  Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
        }
        /// <summary>
        /// Opens a Reader for Non-seeking usage
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="listener"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public static IReader OpenReader(Stream stream, IExtractionListener listener,
            Options options = Options.KeepStreamsOpen)
        {
            stream.CheckNotNull("stream");

            RewindableStream rewindableStream = new RewindableStream(stream);
            rewindableStream.Recording = true;
            if (ZipArchive.IsZipFile(rewindableStream))
            {
                return ZipReader.Open(rewindableStream, listener, options);
            }
            rewindableStream.Rewind();
            rewindableStream.Recording = true;
            if (GZipReader.IsGZip(rewindableStream))
            {
                rewindableStream.Rewind();
                GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
                rewindableStream.Recording = true;
                if (TarReader.IsTarFile(testStream))
                {
                    rewindableStream.Rewind();
                    return TarGZipReader.Open(rewindableStream, listener, options);
                }
                rewindableStream.Rewind();
                return GZipReader.Open(rewindableStream, listener, options);
            }
            rewindableStream.Rewind();
            rewindableStream.Recording = true;
            if (TarReader.IsTarFile(rewindableStream))
            {
                rewindableStream.Rewind();
                return TarReader.Open(rewindableStream, listener, options);
            }
            rewindableStream.Rewind();
            rewindableStream.Recording = true;
            if (RarArchive.IsRarFile(rewindableStream))
            {
                rewindableStream.Rewind();
                return RarReader.Open(rewindableStream, listener, options);
            }
            throw new InvalidOperationException("Cannot determine compressed stream type.");
        }
        /// <summary>
        /// Opens an Archive for random access
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public static IArchive Open(Stream stream, Options options = Options.KeepStreamsOpen)
        {
            stream.CheckNotNull("stream");
            if (!stream.CanRead || !stream.CanSeek)
            {
                throw new ArgumentException("Stream should be readable and seekable");
            }

            if (ZipArchive.IsZipFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return ZipArchive.Open(stream, options);
            }
            stream.Seek(0, SeekOrigin.Begin);
            if (RarArchive.IsRarFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return RarArchive.Open(stream, options);
            }
            throw new InvalidOperationException("Cannot determine compressed stream type.");
        }
 /// <summary>
 /// Opens an Archive for random access
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="readerOptions"></param>
 /// <returns></returns>
 public static IArchive Open(Stream stream, ReaderOptions readerOptions = null)
 {
     stream.CheckNotNull("stream");
     if (!stream.CanRead || !stream.CanSeek)
     {
         throw new ArgumentException("Stream should be readable and seekable");
     }
     readerOptions = readerOptions ?? new ReaderOptions();
     if (ZipArchive.IsZipFile(stream, null))
     {
         stream.Seek(0, SeekOrigin.Begin);
         return(ZipArchive.Open(stream, readerOptions));
     }
     stream.Seek(0, SeekOrigin.Begin);
     if (SevenZipArchive.IsSevenZipFile(stream))
     {
         stream.Seek(0, SeekOrigin.Begin);
         return(SevenZipArchive.Open(stream, readerOptions));
     }
     stream.Seek(0, SeekOrigin.Begin);
     if (GZipArchive.IsGZipFile(stream))
     {
         stream.Seek(0, SeekOrigin.Begin);
         return(GZipArchive.Open(stream, readerOptions));
     }
     stream.Seek(0, SeekOrigin.Begin);
     if (RarArchive.IsRarFile(stream, readerOptions))
     {
         stream.Seek(0, SeekOrigin.Begin);
         return(RarArchive.Open(stream, readerOptions));
     }
     stream.Seek(0, SeekOrigin.Begin);
     if (TarArchive.IsTarFile(stream))
     {
         stream.Seek(0, SeekOrigin.Begin);
         return(TarArchive.Open(stream, readerOptions));
     }
     throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
 }
Beispiel #6
0
        /// <summary>
        /// Opens an Archive for random access
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public static IArchive Open(Stream stream, Options options = Options.KeepStreamsOpen)
        {
            stream.CheckNotNull("stream");
            if (!stream.CanRead || !stream.CanSeek)
            {
                throw new ArgumentException("Stream should be readable and seekable");
            }

            if (ZipArchive.IsZipFile(stream, null))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return(ZipArchive.Open(stream, options, null));
            }
            stream.Seek(0, SeekOrigin.Begin);
            if (RarArchive.IsRarFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return(RarArchive.Open(stream, options));
            }
            stream.Seek(0, SeekOrigin.Begin);
            if (TarArchive.IsTarFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return(TarArchive.Open(stream, options));
            }
            stream.Seek(0, SeekOrigin.Begin);
            if (SevenZipArchive.IsSevenZipFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return(SevenZipArchive.Open(stream, options));
            }
            stream.Seek(0, SeekOrigin.Begin);
            if (GZipArchive.IsGZipFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
                return(GZipArchive.Open(stream, options));
            }
            throw new InvalidOperationException("Cannot determine compressed stream type.");
        }
Beispiel #7
0
        /// <summary>
        /// Opens an Archive for random access
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="readerOptions"></param>
        /// <returns></returns>
        public static IArchive Open(Stream stream, ReaderOptions readerOptions = null)
        {
            stream.CheckNotNull(nameof(stream));
            if (!stream.CanRead || !stream.CanSeek)
            {
                throw new ArgumentException("Stream should be readable and seekable");
            }
            if (readerOptions == null)
            {
                readerOptions = new ReaderOptions();
            }

            ArchiveType?type;

            IsArchive(stream, out type); //test and reset stream position

            if (type != null)
            {
                switch (type.Value)
                {
                case ArchiveType.Zip:
                    return(ZipArchive.Open(stream, readerOptions));

                case ArchiveType.SevenZip:
                    return(SevenZipArchive.Open(stream, readerOptions));

                case ArchiveType.GZip:
                    return(GZipArchive.Open(stream, readerOptions));

                case ArchiveType.Rar:
                    return(RarArchive.Open(stream, readerOptions));

                case ArchiveType.Tar:
                    return(TarArchive.Open(stream, readerOptions));
                }
            }
            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip");
        }
Beispiel #8
0
        /// <summary>
        /// Opens a TarReader for Non-seeking usage with a single volume
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public static TarReader Open(Stream stream, ReaderOptions options = null)
        {
            stream.CheckNotNull(nameof(stream));
            options = options != null ? options: new ReaderOptions();
            RewindableStream rewindableStream = new RewindableStream(stream);

            rewindableStream.StartRecording();
            if (GZipArchive.IsGZipFile(rewindableStream))
            {
                rewindableStream.Rewind(false);
                GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
                if (TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    return(new TarReader(rewindableStream, options, CompressionType.GZip));
                }
                throw new InvalidFormatException("Not a tar file.");
            }

            rewindableStream.Rewind(false);
            rewindableStream.Rewind(true);
            return(new TarReader(rewindableStream, options, CompressionType.None));
        }
Beispiel #9
0
        public static IReader Open(Stream stream, Options options = 1)
        {
            stream.CheckNotNull("stream");
            RewindableStream stream2 = new RewindableStream(stream);

            stream2.StartRecording();
            stream2.Rewind(false);
            if (BZip2Stream.IsBZip2(stream2))
            {
                stream2.Rewind(false);
                if (TarArchive.IsTarFile(new BZip2Stream(stream2, CompressionMode.Decompress, false, false)))
                {
                    stream2.Rewind(true);
                    return(new TarReader(stream2, CompressionType.BZip2, options));
                }
            }
            stream2.Rewind(false);
            if (!TarArchive.IsTarFile(stream2))
            {
                throw new InvalidOperationException("Cannot determine compressed stream type.");
            }
            stream2.Rewind(true);
            return(TarReader.Open(stream2, options));
        }
Beispiel #10
0
 /// <summary>
 /// Takes a seekable Stream as a sources
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 public static RarArchive Open(Stream stream, RarOptions options)
 {
     stream.CheckNotNull("stream");
     return(Open(stream.AsEnumerable(), options));
 }
 /// <summary>
 /// Opens a GZipReader for Non-seeking usage with a single volume
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static GZipReader Open(Stream stream, ReaderOptions options = null)
 {
     stream.CheckNotNull("stream");
     return(new GZipReader(stream, options ?? new ReaderOptions()));
 }
Beispiel #12
0
 /// <summary>
 /// Opens a GZipReader for Non-seeking usage with a single volume
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static GZipReader Open(Stream stream,
                               Options options = Options.KeepStreamsOpen)
 {
     stream.CheckNotNull("stream");
     return(new GZipReader(stream, options));
 }
Beispiel #13
0
 /// <summary>
 /// Takes a seekable Stream as a sources
 /// </summary>
 /// <param name="stream"></param>
 public static RarArchive Open(Stream stream)
 {
     stream.CheckNotNull("stream");
     return(Open(stream.AsEnumerable()));
 }
Beispiel #14
0
 public static SevenZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
 {
     stream.CheckNotNull("stream");
     return(new SevenZipArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())));
 }
Beispiel #15
0
 /// <summary>
 /// Opens a ZipReader for Non-seeking usage with a single volume
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static ZipReader Open(Stream stream, ReaderOptions?options = null)
 {
     stream.CheckNotNull(nameof(stream));
     return(new ZipReader(stream, options ?? new ReaderOptions()));
 }
Beispiel #16
0
 /// <summary>
 /// Opens a RarReader for Non-seeking usage with a single volume
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static RarReader Open(Stream stream, ReaderOptions?options = null)
 {
     stream.CheckNotNull(nameof(stream));
     return(new SingleVolumeRarReader(stream, options ?? new ReaderOptions()));
 }
 /// <summary>
 /// Opens a TarReader for Non-seeking usage with a single volume
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static GZipReader Open(Stream stream, Options options = Options.KeepStreamsOpen)
 {
     stream.CheckNotNull("stream");
     return(Open(stream, new NullExtractionListener(), options));
 }
Beispiel #18
0
 /// <summary>
 /// Takes a seekable Stream as a source
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <param name="password"></param>
 public static RarArchive Open(Stream stream, Options options = Options.KeepStreamsOpen, string password = null)
 {
     stream.CheckNotNull("stream");
     return(Open(stream.AsEnumerable(), options, password));
 }
 /// <summary>
 /// Takes a seekable Stream as a source
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 public static SevenZipArchive Open(Stream stream, Options options)
 {
     stream.CheckNotNull("stream");
     return(new SevenZipArchive(stream, options));
 }
 /// <summary>
 /// Opens a CompressedStreamReader for Non-seeking usage
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static IReader OpenReader(Stream stream, Options options = Options.KeepStreamsOpen)
 {
     stream.CheckNotNull("stream");
     return OpenReader(stream, new NullExtractionListener(), options);
 }
Beispiel #21
0
 /// <summary>
 /// Takes a seekable Stream as a source
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="readerOptions"></param>
 public static TarArchive Open(Stream stream, ReaderOptions readerOptions = null)
 {
     stream.CheckNotNull(nameof(stream));
     return(new TarArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())));
 }
        public static bool TryOpen(Stream stream, ReaderOptions options, ArchiveTypeMask archiveTypes, out IReader reader)
        {
            stream.CheckNotNull("stream");
            options = options ?? new ReaderOptions()
            {
                LeaveStreamOpen = false
            };
            RewindableStream rewindableStream = new RewindableStream(stream);

            rewindableStream.StartRecording();
            if (archiveTypes.HasFlag(ArchiveTypeMask.Zip) && ZipArchive.IsZipFile(rewindableStream, options.Password))
            {
                rewindableStream.Rewind(true);
                reader = ZipReader.Open(rewindableStream, options);
                return(true);
            }
            rewindableStream.Rewind(false);
            if (archiveTypes.HasFlag(ArchiveTypeMask.GZip) && GZipArchive.IsGZipFile(rewindableStream))
            {
                rewindableStream.Rewind(false);
                GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
                if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    reader = new TarReader(rewindableStream, options, CompressionType.GZip);
                    return(true);
                }
                rewindableStream.Rewind(true);
                reader = GZipReader.Open(rewindableStream, options);
                return(true);
            }

            rewindableStream.Rewind(false);
            if (archiveTypes.HasFlag(ArchiveTypeMask.BZip2) && BZip2Stream.IsBZip2(rewindableStream))
            {
                rewindableStream.Rewind(false);
                BZip2Stream testStream = new BZip2Stream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress, false);
                if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    reader = new TarReader(rewindableStream, options, CompressionType.BZip2);
                    return(true);
                }
            }

            rewindableStream.Rewind(false);
            if (archiveTypes.HasFlag(ArchiveTypeMask.LZip) && LZipStream.IsLZipFile(rewindableStream))
            {
                rewindableStream.Rewind(false);
                LZipStream testStream = new LZipStream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress);
                if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    reader = new TarReader(rewindableStream, options, CompressionType.LZip);
                    return(true);
                }
            }
            rewindableStream.Rewind(false);
            if (archiveTypes.HasFlag(ArchiveTypeMask.Rar) && RarArchive.IsRarFile(rewindableStream, options))
            {
                rewindableStream.Rewind(true);
                reader = RarReader.Open(rewindableStream, options);
                return(true);
            }

            rewindableStream.Rewind(false);
            if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(rewindableStream))
            {
                rewindableStream.Rewind(true);
                reader = TarReader.Open(rewindableStream, options);
                return(true);
            }
            rewindableStream.Rewind(false);
            if (XZStream.IsXZStream(rewindableStream))
            {
                rewindableStream.Rewind(true);
                XZStream testStream = new XZStream(rewindableStream);
                if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    reader = new TarReader(rewindableStream, options, CompressionType.Xz);
                    return(true);
                }
            }
            reader = null;
            return(false);
        }
Beispiel #23
0
 public static RarReader Open(Stream stream, string password, Options options = Options.KeepStreamsOpen)
 {
     stream.CheckNotNull("stream");
     return(new SingleVolumeRarReader(stream, password, options));
 }
Beispiel #24
0
 /// <summary>
 /// Takes a seekable Stream as a source
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="password"></param>
 public static ZipArchive Open(Stream stream, string password = null)
 {
     stream.CheckNotNull("stream");
     return(Open(stream, Options.None, password));
 }
 /// <summary>
 /// Opens a TarReader for Non-seeking usage with a single volume
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="listener"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static GZipReader Open(Stream stream, IExtractionListener listener,
                               Options options = Options.KeepStreamsOpen)
 {
     stream.CheckNotNull("stream");
     return(new GZipReader(stream, options, listener));
 }
Beispiel #26
0
 /// <summary>
 /// Takes a seekable Stream as a source
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 public static RarArchive Open(Stream stream, ReaderOptions options = null)
 {
     stream.CheckNotNull(nameof(stream));
     return Open(stream.AsEnumerable(), options ?? new ReaderOptions());
 }
Beispiel #27
0
 /// <summary>
 /// Opens a RarReader for Non-seeking usage with a single volume
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static RarReader Open(Stream stream, RarOptions options = RarOptions.KeepStreamsOpen)
 {
     stream.CheckNotNull("stream");
     return(new SingleVolumeRarReader(stream, options, new NullRarExtractionListener()));
 }
 /// <summary>
 /// Opens a RarReader for Non-seeking usage with a single volume
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static RarReader Open(Stream stream, RarOptions options = RarOptions.KeepStreamsOpen)
 {
     stream.CheckNotNull("stream");
     return new SingleVolumeRarReader(stream, options, new NullRarExtractionListener());
 }
 /// <summary>
 /// Takes a seekable Stream as a source
 /// </summary>
 /// <param name="stream"></param>
 public static SevenZipArchive Open(Stream stream)
 {
     stream.CheckNotNull("stream");
     return(Open(stream, Options.None));
 }
Beispiel #30
0
 /// <summary>
 /// Opens a TarGZipReader for Non-seeking usage with a single volume
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="listener"></param>
 /// <param name="options"></param>
 /// <returns></returns>
 public static TarGZipReader Open(Stream stream, IExtractionListener listener,
                                  Options options = Options.KeepStreamsOpen)
 {
     stream.CheckNotNull("stream");
     return(new TarGZipReader(new GZipStream(stream, CompressionMode.Decompress), options, listener));
 }
        /// <summary>
        /// Opens a Reader for Non-seeking usage
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public static IReader Open(Stream stream, ReaderOptions options = null)
        {
            stream.CheckNotNull("stream");
            options = options ?? new ReaderOptions()
            {
                LeaveStreamOpen = false
            };
            RewindableStream rewindableStream = new RewindableStream(stream);

            rewindableStream.StartRecording();
            if (ZipArchive.IsZipFile(rewindableStream, options.Password))
            {
                rewindableStream.Rewind(true);
                return(ZipReader.Open(rewindableStream, options));
            }
            rewindableStream.Rewind(false);
            if (GZipArchive.IsGZipFile(rewindableStream))
            {
                rewindableStream.Rewind(false);
                GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
                if (TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    return(new TarReader(rewindableStream, options, CompressionType.GZip));
                }
                rewindableStream.Rewind(true);
                return(GZipReader.Open(rewindableStream, options));
            }

            rewindableStream.Rewind(false);
            if (BZip2Stream.IsBZip2(rewindableStream))
            {
                rewindableStream.Rewind(false);
                BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, true);
                if (TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    return(new TarReader(rewindableStream, options, CompressionType.BZip2));
                }
            }

            rewindableStream.Rewind(false);
            if (LZipStream.IsLZipFile(rewindableStream))
            {
                rewindableStream.Rewind(false);
                LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress, true);
                if (TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    return(new TarReader(rewindableStream, options, CompressionType.LZip));
                }
            }
            rewindableStream.Rewind(false);
            if (RarArchive.IsRarFile(rewindableStream, options))
            {
                rewindableStream.Rewind(true);
                return(RarReader.Open(rewindableStream, options));
            }

            rewindableStream.Rewind(false);
            if (TarArchive.IsTarFile(rewindableStream))
            {
                rewindableStream.Rewind(true);
                return(TarReader.Open(rewindableStream, options));
            }
            rewindableStream.Rewind(false);
            if (XZStream.IsXZStream(rewindableStream))
            {
                rewindableStream.Rewind(true);
                XZStream testStream = new XZStream(rewindableStream);
                if (TarArchive.IsTarFile(testStream))
                {
                    rewindableStream.Rewind(true);
                    return(new TarReader(rewindableStream, options, CompressionType.Xz));
                }
            }
            throw new InvalidOperationException("Cannot determine compressed stream type.  Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar, LZip, XZ");
        }
Beispiel #32
0
 /// <summary>
 /// Opens a ZipReader for Non-seeking usage with a single volume
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <param name="password"></param>
 /// <returns></returns>
 public static ZipReader Open(Stream stream, string password = null,
                              Options options = Options.KeepStreamsOpen)
 {
     stream.CheckNotNull("stream");
     return(new ZipReader(stream, options, password));
 }
Beispiel #33
0
 /// <summary>
 /// Takes a seekable Stream as a source
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="readerOptions"></param>
 public static GZipArchive Open(Stream stream, ReaderOptions?readerOptions = null)
 {
     stream.CheckNotNull(nameof(stream));
     return(new GZipArchive(stream, readerOptions ?? new ReaderOptions()));
 }
 /// <summary>
 /// Takes a seekable Stream as a sources
 /// </summary>
 /// <param name="stream"></param>
 public static RarArchive Open(Stream stream)
 {
     stream.CheckNotNull("stream");
     return Open(stream.AsEnumerable());
 }
Beispiel #35
0
 /// <summary>
 /// Takes a seekable Stream as a source
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 /// <param name="password"></param>
 public static ZipArchive Open(Stream stream, Options options, string password = null)
 {
     stream.CheckNotNull("stream");
     return(new ZipArchive(stream, options, password));
 }
 /// <summary>
 /// Takes a seekable Stream as a sources
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="options"></param>
 public static RarArchive Open(Stream stream, RarOptions options)
 {
     stream.CheckNotNull("stream");
     return Open(stream.AsEnumerable(), options);
 }
 /// <summary>
 /// Takes a seekable Stream as a source
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="readerOptions"></param>
 public static TarArchive Open(Stream stream, ReaderOptions readerOptions = null)
 {
     stream.CheckNotNull("stream");
     return(new TarArchive(stream, readerOptions ?? new ReaderOptions()));
 }
Beispiel #38
0
 /// <summary>
 /// Takes a seekable Stream as a source
 /// </summary>
 /// <param name="stream"></param>
 /// <param name="readerOptions"></param>
 public static TarArchive Open(Stream stream, ReaderOptions readerOptions = null)
 {
     stream.CheckNotNull(nameof(stream));
     return(new TarArchive(stream, readerOptions != null ?readerOptions: new ReaderOptions()));
 }