internal static IEnumerable <RarArchiveVolume> GetParts(FileInfo fileInfo, RarOptions options)
{
var part = new FileInfoRarArchiveVolume(fileInfo, options);
yield return(part);
if (!part.ArchiveHeader.ArchiveHeaderFlags.HasFlag(ArchiveFlags.VOLUME))
{
yield break; //if file isn't volume then there is no reason to look
}
ArchiveHeader ah = part.ArchiveHeader;
fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart);
//we use fileinfo because rar is dumb and looks at file names rather than archive info for another volume
while (fileInfo != null)
{
part = new FileInfoRarArchiveVolume(fileInfo, options);
fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart);
if (!fileInfo.Exists)
{
yield break;
}
yield return(part);
}
}
private static RarOptions FixOptions(RarOptions options)
{
//make sure we're closing streams with fileinfo
if (options.HasFlag(RarOptions.KeepStreamsOpen))
{
options = (RarOptions)FlagUtilities.SetFlag(options, RarOptions.KeepStreamsOpen, false);
}
return(options);
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
internal RarArchive(FileInfo fileInfo, RarOptions options)
{
if (!fileInfo.Exists)
{
throw new ArgumentException("File does not exist: " + fileInfo.FullName);
}
lazyVolumes = new LazyReadOnlyCollection <RarArchiveVolume>(RarArchiveVolumeFactory.GetParts(fileInfo, options));
lazyEntries = new LazyReadOnlyCollection <RarArchiveEntry>(RarArchiveEntry.GetEntries(this, Volumes));
}
private IEnumerable <RarReaderEntry> GetEntries(Stream stream, RarOptions options)
{
Volume = new RarReaderVolume(stream, options);
foreach (RarFilePart fp in Volume.ReadFileParts())
{
ValidateArchive(Volume);
yield return(new RarReaderEntry(Volume.IsSolidArchive, fp));
}
}
private static RarOptions FixOptions(RarOptions options)
{
//make sure we're closing streams with fileinfo
if (options.HasFlag(RarOptions.KeepStreamsOpen))
{
options = (RarOptions)FlagUtilities.SetFlag(options, RarOptions.KeepStreamsOpen, false);
}
return options;
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
internal RarArchive(FileInfo fileInfo, RarOptions options)
{
if (!fileInfo.Exists)
{
throw new ArgumentException("File does not exist: " + fileInfo.FullName);
}
lazyVolumes = new LazyReadOnlyCollection<RarArchiveVolume>(RarArchiveVolumeFactory.GetParts(fileInfo, options));
lazyEntries = new LazyReadOnlyCollection<RarArchiveEntry>(RarArchiveEntry.GetEntries(this, Volumes));
}
internal static IEnumerable<RarArchiveVolume> GetParts(IEnumerable<Stream> streams, RarOptions options)
{
foreach (Stream s in streams)
{
if (!s.CanRead || !s.CanSeek)
{
throw new ArgumentException("Stream is not readable and seekable");
}
var part = new StreamRarArchiveVolume(s, options);
yield return part;
}
}
internal static IEnumerable<RarArchiveVolume> GetParts(FileInfo fileInfo, RarOptions options)
{
var part = new FileInfoRarArchiveVolume(fileInfo, options);
yield return part;
if (!part.ArchiveHeader.ArchiveHeaderFlags.HasFlag(ArchiveFlags.VOLUME))
{
yield break; //if file isn't volume then there is no reason to look
}
ArchiveHeader ah = part.ArchiveHeader;
fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart);
//we use fileinfo because rar is dumb and looks at file names rather than archive info for another volume
while (fileInfo != null)
{
part = new FileInfoRarArchiveVolume(fileInfo, options);
fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart);
if (!fileInfo.Exists)
yield break;
yield return part;
}
}
internal FileInfoRarArchiveVolume(FileInfo fileInfo, RarOptions options)
: base(StreamingMode.Seekable, FixOptions(options))
{
FileInfo = fileInfo;
FileParts = base.GetVolumeFileParts().ToReadOnly();
}
internal RarReader(RarOptions options, IRarExtractionListener listener)
{
this.listener = listener;
this.options = options;
listener.CheckNotNull("listener");
}
/// <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()));
}
private int MAX_SFX_SIZE = 0x80000 - 16; //archive.cpp line 136
internal RarHeaderFactory(StreamingMode mode, RarOptions options)
{
StreamingMode = mode;
Options = options;
}
/// <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 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>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
/// <param name="options"></param>
public static RarArchive Open(string filePath, RarOptions options)
{
filePath.CheckNotNullOrEmpty("filePath");
return(Open(new FileInfo(filePath), options));
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
public static RarArchive Open(FileInfo fileInfo, RarOptions options)
{
fileInfo.CheckNotNull("fileInfo");
return new RarArchive(fileInfo, options);
}
/// <summary>
/// Constructor expects a filepath to an existing file.
/// </summary>
/// <param name="filePath"></param>
/// <param name="options"></param>
public static RarArchive Open(string filePath, RarOptions options)
{
filePath.CheckNotNullOrEmpty("filePath");
return Open(new FileInfo(filePath), options);
}
internal RarArchiveVolume(StreamingMode mode, RarOptions options)
: base(mode, options)
{
}
internal RarReaderVolume(Stream stream, RarOptions options)
: base(StreamingMode.Streaming, options)
{
Stream = stream;
this.streamOwner = !options.HasFlag(RarOptions.KeepStreamsOpen);
}
internal SingleVolumeRarReader(Stream stream, RarOptions options, IRarExtractionListener listener)
: base(options, listener)
{
this.stream = stream;
}
internal RarArchiveVolume(StreamingMode mode, RarOptions options)
: base(mode, options)
{
}
internal SingleVolumeRarReader(Stream stream, RarOptions options, IRarExtractionListener listener)
: base(options, listener)
{
this.stream = stream;
}
internal RarVolume(StreamingMode mode, RarOptions options)
{
this.options = options;
headerFactory = new RarHeaderFactory(mode, options);
}
internal RarVolume(StreamingMode mode, RarOptions options)
{
this.options = options;
headerFactory = new RarHeaderFactory(mode, 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>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
public static RarArchive Open(FileInfo fileInfo, RarOptions options)
{
fileInfo.CheckNotNull("fileInfo");
return(new RarArchive(fileInfo, options));
}
/// <summary>
/// Takes multiple seekable Streams for a multi-part archive
/// </summary>
/// <param name="streams"></param>
/// <param name="options"></param>
public static RarArchive Open(IEnumerable<Stream> streams, RarOptions options)
{
streams.CheckNotNull("streams");
return new RarArchive(streams, options);
}
/// <summary>
/// Takes multiple seekable Streams for a multi-part archive
/// </summary>
/// <param name="streams"></param>
/// <param name="options"></param>
public static RarArchive Open(IEnumerable <Stream> streams, RarOptions options)
{
streams.CheckNotNull("streams");
return(new RarArchive(streams, options));
}
internal RarReader(RarOptions options, IRarExtractionListener listener)
{
this.listener = listener;
this.options = options;
listener.CheckNotNull("listener");
}
/// <summary>
/// Takes multiple seekable Streams for a multi-part archive
/// </summary>
/// <param name="streams"></param>
/// <param name="options"></param>
internal RarArchive(IEnumerable <Stream> streams, RarOptions options)
{
lazyVolumes = new LazyReadOnlyCollection <RarArchiveVolume>(RarArchiveVolumeFactory.GetParts(streams, options));
lazyEntries = new LazyReadOnlyCollection <RarArchiveEntry>(RarArchiveEntry.GetEntries(this, Volumes));
}
internal StreamRarArchiveVolume(Stream stream, RarOptions options)
: base(StreamingMode.Seekable, options)
{
Stream = stream;
this.streamOwner = !options.HasFlag(RarOptions.KeepStreamsOpen);
}
private IEnumerable<RarReaderEntry> GetEntries(Stream stream, RarOptions options)
{
Volume = new RarReaderVolume(stream, options);
foreach (RarFilePart fp in Volume.ReadFileParts())
{
ValidateArchive(Volume);
yield return new RarReaderEntry(Volume.IsSolidArchive, fp);
}
}
internal FileInfoRarArchiveVolume(FileInfo fileInfo, RarOptions options)
: base(StreamingMode.Seekable, FixOptions(options))
{
FileInfo = fileInfo;
FileParts = base.GetVolumeFileParts().ToReadOnly();
}
/// <summary>
/// Opens a RarReader for Non-seeking usage with multiple volumes
/// </summary>
/// <param name="streams"></param>
/// <param name="options"></param>
/// <returns></returns>
public static RarReader Open(IEnumerable <Stream> streams, RarOptions options = RarOptions.KeepStreamsOpen)
{
streams.CheckNotNull("streams");
return(new MultiVolumeRarReader(streams, options, new NullRarExtractionListener()));
}
/// <summary>
/// Opens a RarReader for Non-seeking usage with multiple volumes
/// </summary>
/// <param name="streams"></param>
/// <param name="options"></param>
/// <returns></returns>
public static RarReader Open(IEnumerable<Stream> streams, RarOptions options = RarOptions.KeepStreamsOpen)
{
streams.CheckNotNull("streams");
return new MultiVolumeRarReader(streams, options, new NullRarExtractionListener());
}
internal static IEnumerable <RarArchiveVolume> GetParts(IEnumerable <Stream> streams, RarOptions options)
{
foreach (Stream s in streams)
{
if (!s.CanRead || !s.CanSeek)
{
throw new ArgumentException("Stream is not readable and seekable");
}
var part = new StreamRarArchiveVolume(s, options);
yield return(part);
}
}
private int MAX_SFX_SIZE = 0x80000 - 16; //archive.cpp line 136
internal RarHeaderFactory(StreamingMode mode, RarOptions options)
{
StreamingMode = mode;
Options = options;
}
internal RarReaderVolume(Stream stream, RarOptions options)
: base(StreamingMode.Streaming, options)
{
Stream = stream;
this.streamOwner = !options.HasFlag(RarOptions.KeepStreamsOpen);
}
/// <summary>
/// Takes multiple seekable Streams for a multi-part archive
/// </summary>
/// <param name="streams"></param>
/// <param name="options"></param>
internal RarArchive(IEnumerable<Stream> streams, RarOptions options)
{
lazyVolumes = new LazyReadOnlyCollection<RarArchiveVolume>(RarArchiveVolumeFactory.GetParts(streams, options));
lazyEntries = new LazyReadOnlyCollection<RarArchiveEntry>(RarArchiveEntry.GetEntries(this, Volumes));
}
internal MultiVolumeRarReader(IEnumerable <Stream> streams, RarOptions options, IRarExtractionListener listener)
: base(options, listener)
{
this.streams = streams.GetEnumerator();
}
internal StreamRarArchiveVolume(Stream stream, RarOptions options)
: base(StreamingMode.Seekable, options)
{
Stream = stream;
this.streamOwner = !options.HasFlag(RarOptions.KeepStreamsOpen);
}
