EmuHawk: SharpCompress implementation for Mono

BizHawk.Client.Common/SharpCompress/Archives/AbstractArchive.cs

@@ -0,0 +1,179 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using SharpCompress.Common;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives
+{
+    public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtractionListener
+        where TEntry : IArchiveEntry
+        where TVolume : IVolume
+    {
+        private readonly LazyReadOnlyCollection<TVolume> lazyVolumes;
+        private readonly LazyReadOnlyCollection<TEntry> lazyEntries;
+
+        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
+        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
+
+        public event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
+        public event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
+
+        protected ReaderOptions ReaderOptions { get; }
+
+        private bool disposed;
+
+#if !NO_FILE
+        internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions)
+        {
+            Type = type;
+            if (!fileInfo.Exists)
+            {
+                throw new ArgumentException("File does not exist: " + fileInfo.FullName);
+            }
+            ReaderOptions = readerOptions;
+            readerOptions.LeaveStreamOpen = false;
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(fileInfo));
+            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+        }
+
+
+        protected abstract IEnumerable<TVolume> LoadVolumes(FileInfo file);
+#endif
+
+        internal AbstractArchive(ArchiveType type, IEnumerable<Stream> streams, ReaderOptions readerOptions)
+        {
+            Type = type;
+            ReaderOptions = readerOptions;
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams)));
+            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+        }
+
+        internal AbstractArchive(ArchiveType type)
+        {
+            Type = type;
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
+            lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
+        }
+
+        public ArchiveType Type { get; }
+
+        void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry)
+        {
+            EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+        }
+
+        void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry)
+        {
+            EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+        }
+
+        private static Stream CheckStreams(Stream stream)
+        {
+            if (!stream.CanSeek || !stream.CanRead)
+            {
+                throw new ArgumentException("Archive streams must be Readable and Seekable");
+            }
+            return stream;
+        }
+
+        /// <summary>
+        /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
+        /// </summary>
+        public virtual ICollection<TEntry> Entries { get { return lazyEntries; } }
+
+        /// <summary>
+        /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
+        /// </summary>
+        public ICollection<TVolume> Volumes { get { return lazyVolumes; } }
+
+        /// <summary>
+        /// The total size of the files compressed in the archive.
+        /// </summary>
+        public virtual long TotalSize { get { return Entries.Aggregate(0L, (total, cf) => total + cf.CompressedSize); } }
+
+        /// <summary>
+        /// The total size of the files as uncompressed in the archive.
+        /// </summary>
+        public virtual long TotalUncompressSize { get { return Entries.Aggregate(0L, (total, cf) => total + cf.Size); } }
+
+        protected abstract IEnumerable<TVolume> LoadVolumes(IEnumerable<Stream> streams);
+        protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);
+
+        IEnumerable<IArchiveEntry> IArchive.Entries { get { return Entries.Cast<IArchiveEntry>(); } }
+
+        IEnumerable<IVolume> IArchive.Volumes { get { return lazyVolumes.Cast<IVolume>(); } }
+
+        public virtual void Dispose()
+        {
+            if (!disposed)
+            {
+                lazyVolumes.ForEach(v => v.Dispose());
+                lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
+                disposed = true;
+            }
+        }
+
+        void IArchiveExtractionListener.EnsureEntriesLoaded()
+        {
+            lazyEntries.EnsureFullyLoaded();
+            lazyVolumes.EnsureFullyLoaded();
+        }
+
+        void IExtractionListener.FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes)
+        {
+            CompressedBytesRead?.Invoke(this, new CompressedBytesReadEventArgs
+            {
+                CurrentFilePartCompressedBytesRead = currentPartCompressedBytes,
+                CompressedBytesRead = compressedReadBytes
+            });
+        }
+
+        void IExtractionListener.FireFilePartExtractionBegin(string name, long size, long compressedSize)
+        {
+            FilePartExtractionBegin?.Invoke(this, new FilePartExtractionBeginEventArgs
+            {
+                CompressedSize = compressedSize,
+                Size = size,
+                Name = name
+            });
+        }
+
+        /// <summary>
+        /// Use this method to extract all entries in an archive in order.
+        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be 
+        /// extracted sequentially for the best performance.
+        /// 
+        /// This method will load all entry information from the archive.
+        /// 
+        /// WARNING: this will reuse the underlying stream for the archive.  Errors may 
+        /// occur if this is used at the same time as other extraction methods on this instance.
+        /// </summary>
+        /// <returns></returns>
+        public IReader ExtractAllEntries()
+        {
+            ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
+            return CreateReaderForSolidExtraction();
+        }
+
+        protected abstract IReader CreateReaderForSolidExtraction();
+
+        /// <summary>
+        /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
+        /// </summary>
+        public virtual bool IsSolid { get { return false; } }
+
+        /// <summary>
+        /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
+        /// </summary>
+        public bool IsComplete
+        {
+            get
+            {
+                ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
+                return Entries.All(x => x.IsComplete);
+            }
+        }
+    }
+}

BizHawk.Client.Common/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using SharpCompress.Common;
+using SharpCompress.Readers;
+using SharpCompress.Writers;
+
+namespace SharpCompress.Archives
+{
+    public abstract class AbstractWritableArchive<TEntry, TVolume> : AbstractArchive<TEntry, TVolume>, IWritableArchive
+        where TEntry : IArchiveEntry
+        where TVolume : IVolume
+    {
+        private readonly List<TEntry> newEntries = new List<TEntry>();
+        private readonly List<TEntry> removedEntries = new List<TEntry>();
+
+        private readonly List<TEntry> modifiedEntries = new List<TEntry>();
+        private bool hasModifications;
+
+        internal AbstractWritableArchive(ArchiveType type)
+            : base(type)
+        {
+        }
+
+        internal AbstractWritableArchive(ArchiveType type, Stream stream, ReaderOptions readerFactoryOptions)
+            : base(type, stream.AsEnumerable(), readerFactoryOptions)
+        {
+        }
+
+#if !NO_FILE
+        internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerFactoryOptions)
+            : base(type, fileInfo, readerFactoryOptions)
+        {
+        }
+#endif
+
+        public override ICollection<TEntry> Entries
+        {
+            get
+            {
+                if (hasModifications)
+                {
+                    return modifiedEntries;
+                }
+                return base.Entries;
+            }
+        }
+
+        private void RebuildModifiedCollection()
+        {
+            hasModifications = true;
+            newEntries.RemoveAll(v => removedEntries.Contains(v));
+            modifiedEntries.Clear();
+            modifiedEntries.AddRange(OldEntries.Concat(newEntries));
+        }
+
+        private IEnumerable<TEntry> OldEntries { get { return base.Entries.Where(x => !removedEntries.Contains(x)); } }
+
+        public void RemoveEntry(TEntry entry)
+        {
+            if (!removedEntries.Contains(entry))
+            {
+                removedEntries.Add(entry);
+                RebuildModifiedCollection();
+            }
+        }
+
+        void IWritableArchive.RemoveEntry(IArchiveEntry entry)
+        {
+            RemoveEntry((TEntry)entry);
+        }
+
+        public TEntry AddEntry(string key, Stream source,
+                               long size = 0, DateTime? modified = null)
+        {
+            return AddEntry(key, source, false, size, modified);
+        }
+
+        IArchiveEntry IWritableArchive.AddEntry(string key, Stream source, bool closeStream, long size, DateTime? modified)
+        {
+            return AddEntry(key, source, closeStream, size, modified);
+        }
+
+        public TEntry AddEntry(string key, Stream source, bool closeStream,
+                               long size = 0, DateTime? modified = null)
+        {
+            if (key.StartsWith("/")
+                || key.StartsWith("\\"))
+            {
+                key = key.Substring(1);
+            }
+            if (DoesKeyMatchExisting(key))
+            {
+                throw new ArchiveException("Cannot add entry with duplicate key: " + key);
+            }
+            var entry = CreateEntry(key, source, size, modified, closeStream);
+            newEntries.Add(entry);
+            RebuildModifiedCollection();
+            return entry;
+        }
+
+        private bool DoesKeyMatchExisting(string key)
+        {
+            foreach (var path in Entries.Select(x => x.Key))
+            {
+                var p = path.Replace('/', '\\');
+                if (p.StartsWith("\\"))
+                {
+                    p = p.Substring(1);
+                }
+                return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
+            }
+            return false;
+        }
+
+        public void SaveTo(Stream stream, WriterOptions options)
+        {
+            //reset streams of new entries
+            newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
+            SaveTo(stream, options, OldEntries, newEntries);
+        }
+
+        protected TEntry CreateEntry(string key, Stream source, long size, DateTime? modified,
+                                     bool closeStream)
+        {
+            if (!source.CanRead || !source.CanSeek)
+            {
+                throw new ArgumentException("Streams must be readable and seekable to use the Writing Archive API");
+            }
+            return CreateEntryInternal(key, source, size, modified, closeStream);
+        }
+
+        protected abstract TEntry CreateEntryInternal(string key, Stream source, long size, DateTime? modified,
+                                                      bool closeStream);
+
+        protected abstract void SaveTo(Stream stream, WriterOptions options, IEnumerable<TEntry> oldEntries, IEnumerable<TEntry> newEntries);
+
+        public override void Dispose()
+        {
+            base.Dispose();
+            newEntries.Cast<Entry>().ForEach(x => x.Close());
+            removedEntries.Cast<Entry>().ForEach(x => x.Close());
+            modifiedEntries.Cast<Entry>().ForEach(x => x.Close());
+        }
+    }
+}