/// <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."); }
/// <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"); }
/// <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."); }
/// <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"); }
/// <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)); }
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)); }
/// <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())); }
/// <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)); }
/// <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())); }
public static SevenZipArchive Open(Stream stream, ReaderOptions readerOptions = null) { stream.CheckNotNull("stream"); return(new SevenZipArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()))); }
/// <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())); }
/// <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)); }
/// <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); }
/// <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); }
public static RarReader Open(Stream stream, string password, Options options = Options.KeepStreamsOpen) { stream.CheckNotNull("stream"); return(new SingleVolumeRarReader(stream, password, options)); }
/// <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)); }
/// <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()); }
/// <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)); }
/// <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"); }
/// <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)); }
/// <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()); }
/// <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())); }
/// <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())); }