Implement shell wrappers for extractable types without a current model

SabreTools.Serialization.Test/Wrappers/BZip2Tests.cs

@@ -0,0 +1,61 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Wrappers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Wrappers
+{
+    public class BZip2Tests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var actual = BZip2.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var actual = BZip2.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var actual = BZip2.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var actual = BZip2.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var actual = BZip2.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var actual = BZip2.Create(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Wrappers/GZipTests.cs

@@ -0,0 +1,61 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Wrappers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Wrappers
+{
+    public class GZipTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var actual = GZip.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var actual = GZip.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var actual = GZip.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var actual = GZip.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var actual = GZip.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var actual = GZip.Create(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Wrappers/RARTests.cs

@@ -0,0 +1,61 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Wrappers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Wrappers
+{
+    public class RARTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var actual = RAR.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var actual = RAR.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var actual = RAR.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var actual = RAR.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var actual = RAR.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var actual = RAR.Create(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Wrappers/SevenZipTests.cs

@@ -0,0 +1,61 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Wrappers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Wrappers
+{
+    public class SevenZipTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var actual = SevenZip.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var actual = SevenZip.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var actual = SevenZip.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var actual = SevenZip.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var actual = SevenZip.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var actual = SevenZip.Create(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Wrappers/TapeArchiveTests.cs

@@ -0,0 +1,61 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Wrappers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Wrappers
+{
+    public class TapeArchiveTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var actual = TapeArchive.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var actual = TapeArchive.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var actual = TapeArchive.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var actual = TapeArchive.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var actual = TapeArchive.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var actual = TapeArchive.Create(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization.Test/Wrappers/XZTests.cs

@@ -0,0 +1,61 @@
+using System.IO;
+using System.Linq;
+using SabreTools.Serialization.Wrappers;
+using Xunit;
+
+namespace SabreTools.Serialization.Test.Wrappers
+{
+    public class XZTests
+    {
+        [Fact]
+        public void NullArray_Null()
+        {
+            byte[]? data = null;
+            int offset = 0;
+            var actual = XZ.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void EmptyArray_Null()
+        {
+            byte[]? data = [];
+            int offset = 0;
+            var actual = XZ.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidArray_Null()
+        {
+            byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
+            int offset = 0;
+            var actual = XZ.Create(data, offset);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void NullStream_Null()
+        {
+            Stream? data = null;
+            var actual = XZ.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void EmptyStream_Null()
+        {
+            Stream? data = new MemoryStream([]);
+            var actual = XZ.Create(data);
+            Assert.Null(actual);
+        }
+
+        [Fact(Skip = "This will never pass with the current code")]
+        public void InvalidStream_Null()
+        {
+            Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
+            var actual = XZ.Create(data);
+            Assert.Null(actual);
+        }
+    }
+}

SabreTools.Serialization/Wrappers/BZip2.cs

@@ -0,0 +1,68 @@
+using System.IO;
+
+namespace SabreTools.Serialization.Wrappers
+{
+    /// <summary>
+    /// This is a shell wrapper; one that does not contain
+    /// any actual parsing. It is used as a placeholder for
+    /// types that typically do not have models.
+    /// </summary>
+    public class BZip2 : WrapperBase
+    {
+        #region Descriptive Properties
+
+        /// <inheritdoc/>
+        public override string DescriptionString => "bzip2 Archive";
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a BZip2 archive from a byte array and offset
+        /// </summary>
+        /// <param name="data">Byte array representing the archive</param>
+        /// <param name="offset">Offset within the array to parse</param>
+        /// <returns>A BZip2 wrapper on success, null on failure</returns>
+        public static BZip2? Create(byte[]? data, int offset)
+        {
+            // If the data is invalid
+            if (data == null || data.Length == 0)
+                return null;
+
+            // If the offset is out of bounds
+            if (offset < 0 || offset >= data.Length)
+                return null;
+
+            // Create a memory stream and use that
+            var dataStream = new MemoryStream(data, offset, data.Length - offset);
+            return Create(dataStream);
+        }
+
+        /// <summary>
+        /// Create a BZip2 archive from a Stream
+        /// </summary>
+        /// <param name="data">Stream representing the archive</param>
+        /// <returns>A BZip2 wrapper on success, null on failure</returns>
+        public static BZip2? Create(Stream? data)
+        {
+            // If the data is invalid
+            if (data == null || !data.CanRead)
+                return null;
+
+            return new BZip2();
+        }
+
+        #endregion
+
+        #region JSON Export
+
+#if NETCOREAPP
+        /// <inheritdoc/>
+        public override string ExportJSON() => throw new System.NotImplementedException();
+
+#endif
+
+        #endregion
+    }
+}

SabreTools.Serialization/Wrappers/GZip.cs

@@ -0,0 +1,67 @@
+using System.IO;
+
+namespace SabreTools.Serialization.Wrappers
+{
+    /// <summary>
+    /// This is a shell wrapper; one that does not contain
+    /// any actual parsing. It is used as a placeholder for
+    /// types that typically do not have models.
+    /// </summary>
+    public class GZip : WrapperBase
+    {
+        #region Descriptive Properties
+
+        /// <inheritdoc/>
+        public override string DescriptionString => "gzip Archive";
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a GZip archive from a byte array and offset
+        /// </summary>
+        /// <param name="data">Byte array representing the archive</param>
+        /// <param name="offset">Offset within the array to parse</param>
+        /// <returns>A GZip wrapper on success, null on failure</returns>
+        public static GZip? Create(byte[]? data, int offset)
+        {
+            // If the data is invalid
+            if (data == null || data.Length == 0)
+                return null;
+
+            // If the offset is out of bounds
+            if (offset < 0 || offset >= data.Length)
+                return null;
+
+            // Create a memory stream and use that
+            var dataStream = new MemoryStream(data, offset, data.Length - offset);
+            return Create(dataStream);
+        }
+
+        /// <summary>
+        /// Create a GZip archive from a Stream
+        /// </summary>
+        /// <param name="data">Stream representing the archive</param>
+        /// <returns>A GZip wrapper on success, null on failure</returns>
+        public static GZip? Create(Stream? data)
+        {
+            // If the data is invalid
+            if (data == null || !data.CanRead)
+                return null;
+
+            return new GZip();
+        }
+
+        #endregion
+
+        #region JSON Export
+
+#if NETCOREAPP
+        /// <inheritdoc/>
+        public override string ExportJSON() => throw new System.NotImplementedException();
+#endif
+
+        #endregion
+    }
+}

SabreTools.Serialization/Wrappers/RAR.cs

@@ -0,0 +1,67 @@
+using System.IO;
+
+namespace SabreTools.Serialization.Wrappers
+{
+    /// <summary>
+    /// This is a shell wrapper; one that does not contain
+    /// any actual parsing. It is used as a placeholder for
+    /// types that typically do not have models.
+    /// </summary>
+    public class RAR : WrapperBase
+    {
+        #region Descriptive Properties
+
+        /// <inheritdoc/>
+        public override string DescriptionString => "RAR Archive (or Derived Format)";
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a RAR archive (or derived format) from a byte array and offset
+        /// </summary>
+        /// <param name="data">Byte array representing the archive</param>
+        /// <param name="offset">Offset within the array to parse</param>
+        /// <returns>A RAR wrapper on success, null on failure</returns>
+        public static RAR? Create(byte[]? data, int offset)
+        {
+            // If the data is invalid
+            if (data == null || data.Length == 0)
+                return null;
+
+            // If the offset is out of bounds
+            if (offset < 0 || offset >= data.Length)
+                return null;
+
+            // Create a memory stream and use that
+            var dataStream = new MemoryStream(data, offset, data.Length - offset);
+            return Create(dataStream);
+        }
+
+        /// <summary>
+        /// Create a RAR archive (or derived format) from a Stream
+        /// </summary>
+        /// <param name="data">Stream representing the archive</param>
+        /// <returns>A RAR wrapper on success, null on failure</returns>
+        public static RAR? Create(Stream? data)
+        {
+            // If the data is invalid
+            if (data == null || !data.CanRead)
+                return null;
+
+            return new RAR();
+        }
+
+        #endregion
+
+        #region JSON Export
+
+#if NETCOREAPP
+        /// <inheritdoc/>
+        public override string ExportJSON() => throw new System.NotImplementedException();
+#endif
+
+        #endregion
+    }
+}

SabreTools.Serialization/Wrappers/SevenZip.cs

@@ -0,0 +1,67 @@
+using System.IO;
+
+namespace SabreTools.Serialization.Wrappers
+{
+    /// <summary>
+    /// This is a shell wrapper; one that does not contain
+    /// any actual parsing. It is used as a placeholder for
+    /// types that typically do not have models.
+    /// </summary>
+    public class SevenZip : WrapperBase
+    {
+        #region Descriptive Properties
+
+        /// <inheritdoc/>
+        public override string DescriptionString => "7-zip Archive (or Derived Format)";
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a SevenZip archive (or derived format) from a byte array and offset
+        /// </summary>
+        /// <param name="data">Byte array representing the archive</param>
+        /// <param name="offset">Offset within the array to parse</param>
+        /// <returns>A SevenZip wrapper on success, null on failure</returns>
+        public static SevenZip? Create(byte[]? data, int offset)
+        {
+            // If the data is invalid
+            if (data == null || data.Length == 0)
+                return null;
+
+            // If the offset is out of bounds
+            if (offset < 0 || offset >= data.Length)
+                return null;
+
+            // Create a memory stream and use that
+            var dataStream = new MemoryStream(data, offset, data.Length - offset);
+            return Create(dataStream);
+        }
+
+        /// <summary>
+        /// Create a SevenZip archive (or derived format) from a Stream
+        /// </summary>
+        /// <param name="data">Stream representing the archive</param>
+        /// <returns>A SevenZip wrapper on success, null on failure</returns>
+        public static SevenZip? Create(Stream? data)
+        {
+            // If the data is invalid
+            if (data == null || !data.CanRead)
+                return null;
+
+            return new SevenZip();
+        }
+
+        #endregion
+
+        #region JSON Export
+
+#if NETCOREAPP
+        /// <inheritdoc/>
+        public override string ExportJSON() => throw new System.NotImplementedException();
+#endif
+
+        #endregion
+    }
+}

SabreTools.Serialization/Wrappers/TapeArchive.cs

@@ -0,0 +1,67 @@
+using System.IO;
+
+namespace SabreTools.Serialization.Wrappers
+{
+    /// <summary>
+    /// This is a shell wrapper; one that does not contain
+    /// any actual parsing. It is used as a placeholder for
+    /// types that typically do not have models.
+    /// </summary>
+    public class TapeArchive : WrapperBase
+    {
+        #region Descriptive Properties
+
+        /// <inheritdoc/>
+        public override string DescriptionString => "Tape Archive (or Derived Format)";
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a tape archive (or derived format) from a byte array and offset
+        /// </summary>
+        /// <param name="data">Byte array representing the archive</param>
+        /// <param name="offset">Offset within the array to parse</param>
+        /// <returns>A tape archive wrapper on success, null on failure</returns>
+        public static TapeArchive? Create(byte[]? data, int offset)
+        {
+            // If the data is invalid
+            if (data == null || data.Length == 0)
+                return null;
+
+            // If the offset is out of bounds
+            if (offset < 0 || offset >= data.Length)
+                return null;
+
+            // Create a memory stream and use that
+            var dataStream = new MemoryStream(data, offset, data.Length - offset);
+            return Create(dataStream);
+        }
+
+        /// <summary>
+        /// Create a tape archive (or derived format) from a Stream
+        /// </summary>
+        /// <param name="data">Stream representing the archive</param>
+        /// <returns>A tape archive wrapper on success, null on failure</returns>
+        public static TapeArchive? Create(Stream? data)
+        {
+            // If the data is invalid
+            if (data == null || !data.CanRead)
+                return null;
+
+            return new TapeArchive();
+        }
+
+        #endregion
+
+        #region JSON Export
+
+#if NETCOREAPP
+        /// <inheritdoc/>
+        public override string ExportJSON() => throw new System.NotImplementedException();
+#endif
+
+        #endregion
+    }
+}

SabreTools.Serialization/Wrappers/WrapperBaseT.cs

@@ -224,9 +224,7 @@ namespace SabreTools.Serialization.Wrappers
         #region JSON Export
 
 #if NETCOREAPP
-        /// <summary>
-        /// Export the item information as JSON
-        /// </summary>
+        /// <inheritdoc/>
         public override string ExportJSON() => System.Text.Json.JsonSerializer.Serialize(Model, _jsonSerializerOptions);
 #endif
 

SabreTools.Serialization/Wrappers/WrapperFactory.cs

@@ -20,13 +20,13 @@ namespace SabreTools.Serialization.Wrappers
                 WrapperType.BDPlusSVM => BDPlusSVM.Create(data),
                 WrapperType.BFPK => BFPK.Create(data),
                 WrapperType.BSP => BSP.Create(data),
-                WrapperType.BZip2 => null,// TODO: Implement wrapper
+                WrapperType.BZip2 => BZip2.Create(data),
                 WrapperType.CFB => CFB.Create(data),
                 WrapperType.CHD => CHD.Create(data),
                 WrapperType.CIA => CIA.Create(data),
                 WrapperType.Executable => CreateExecutableWrapper(data),
                 WrapperType.GCF => GCF.Create(data),
-                WrapperType.GZIP => null,// TODO: Implement wrapper
+                WrapperType.GZip => GZip.Create(data),
                 WrapperType.IniFile => null,// TODO: Implement wrapper
                 WrapperType.InstallShieldArchiveV3 => InstallShieldArchiveV3.Create(data),
                 WrapperType.InstallShieldCAB => InstallShieldCabinet.Create(data),
@@ -46,19 +46,19 @@ namespace SabreTools.Serialization.Wrappers
                 WrapperType.PlayJAudioFile => PlayJAudioFile.Create(data),
                 WrapperType.PlayJPlaylist => PlayJPlaylist.Create(data),
                 WrapperType.Quantum => Quantum.Create(data),
-                WrapperType.RAR => null,// TODO: Implement wrapper
+                WrapperType.RAR => RAR.Create(data),
                 WrapperType.RealArcadeInstaller => null,// TODO: Implement wrapper
                 WrapperType.RealArcadeMezzanine => null,// TODO: Implement wrapper
                 WrapperType.SecuROMDFA => SecuROMDFA.Create(data),
-                WrapperType.SevenZip => null,// TODO: Implement wrapper
+                WrapperType.SevenZip => SevenZip.Create(data),
                 WrapperType.SFFS => null,// TODO: Implement wrapper
                 WrapperType.SGA => SGA.Create(data),
-                WrapperType.TapeArchive => null,// TODO: Implement wrapper
+                WrapperType.TapeArchive => TapeArchive.Create(data),
                 WrapperType.Textfile => null,// TODO: Implement wrapper
                 WrapperType.VBSP => VBSP.Create(data),
                 WrapperType.VPK => VPK.Create(data),
                 WrapperType.WAD => WAD3.Create(data),
-                WrapperType.XZ => null,// TODO: Implement wrapper
+                WrapperType.XZ => XZ.Create(data),
                 WrapperType.XZP => XZP.Create(data),
                 _ => null,
             };
@@ -299,13 +299,13 @@ namespace SabreTools.Serialization.Wrappers
             #endregion
 
             // TODO: Use constants from Models here
-            #region GZIP
+            #region GZip
 
             if (magic.StartsWith([Models.GZIP.Constants.ID1, Models.GZIP.Constants.ID2]))
-                return WrapperType.GZIP;
+                return WrapperType.GZip;
 
             if (extension.Equals("gz", StringComparison.OrdinalIgnoreCase))
-                return WrapperType.GZIP;
+                return WrapperType.GZip;
 
             #endregion
 

SabreTools.Serialization/Wrappers/WrapperType.cs

@@ -33,7 +33,6 @@ namespace SabreTools.Serialization.Wrappers
         /// <summary>
         /// bzip2 archive
         /// </summary>
-        /// <remarks>Currently has no IWrapper implementation</remarks>
         BZip2,
 
         /// <summary>
@@ -65,8 +64,7 @@ namespace SabreTools.Serialization.Wrappers
         /// <summary>
         /// gzip archive
         /// </summary>
-        /// <remarks>Currently has no IWrapper implementation</remarks>
-        GZIP,
+        GZip,
 
         /// <summary>
         /// Key-value pair INI file
@@ -170,7 +168,6 @@ namespace SabreTools.Serialization.Wrappers
         /// <summary>
         /// RAR archive
         /// </summary>
-        /// <remarks>Currently has no IWrapper implementation</remarks>
         RAR,
 
         /// <summary>
@@ -193,7 +190,6 @@ namespace SabreTools.Serialization.Wrappers
         /// <summary>
         /// 7-zip archive
         /// </summary>
-        /// <remarks>Currently has no IWrapper implementation</remarks>
         SevenZip,
 
         /// <summary>
@@ -210,7 +206,6 @@ namespace SabreTools.Serialization.Wrappers
         /// <summary>
         /// Tape archive
         /// </summary>
-        /// <remarks>Currently has no IWrapper implementation</remarks>
         TapeArchive,
 
         /// <summary>
@@ -247,7 +242,6 @@ namespace SabreTools.Serialization.Wrappers
         /// <summary>
         /// xz archive
         /// </summary>
-        /// <remarks>Currently has no IWrapper implementation</remarks>
         XZ,
 
         /// <summary>

SabreTools.Serialization/Wrappers/XZ.cs

@@ -0,0 +1,67 @@
+using System.IO;
+
+namespace SabreTools.Serialization.Wrappers
+{
+    /// <summary>
+    /// This is a shell wrapper; one that does not contain
+    /// any actual parsing. It is used as a placeholder for
+    /// types that typically do not have models.
+    /// </summary>
+    public class XZ : WrapperBase
+    {
+        #region Descriptive Properties
+
+        /// <inheritdoc/>
+        public override string DescriptionString => "xz Archive";
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a XZ archive from a byte array and offset
+        /// </summary>
+        /// <param name="data">Byte array representing the archive</param>
+        /// <param name="offset">Offset within the array to parse</param>
+        /// <returns>A XZ wrapper on success, null on failure</returns>
+        public static XZ? Create(byte[]? data, int offset)
+        {
+            // If the data is invalid
+            if (data == null || data.Length == 0)
+                return null;
+
+            // If the offset is out of bounds
+            if (offset < 0 || offset >= data.Length)
+                return null;
+
+            // Create a memory stream and use that
+            var dataStream = new MemoryStream(data, offset, data.Length - offset);
+            return Create(dataStream);
+        }
+
+        /// <summary>
+        /// Create a XZ archive from a Stream
+        /// </summary>
+        /// <param name="data">Stream representing the archive</param>
+        /// <returns>A XZ wrapper on success, null on failure</returns>
+        public static XZ? Create(Stream? data)
+        {
+            // If the data is invalid
+            if (data == null || !data.CanRead)
+                return null;
+
+            return new XZ();
+        }
+
+        #endregion
+
+        #region JSON Export
+
+#if NETCOREAPP
+        /// <inheritdoc/>
+        public override string ExportJSON() => throw new System.NotImplementedException();
+#endif
+
+        #endregion
+    }
+}