Create and use base class for readers/writers

SabreTools.DatFiles/DatFile.cs

@@ -15,6 +15,7 @@ using SabreTools.DatItems.Formats;
 using SabreTools.Filter;
 using SabreTools.Hashing;
 using SabreTools.Logging;
+using SabreTools.Serialization.Interfaces;
 
 namespace SabreTools.DatFiles
 {
@@ -661,4 +662,63 @@ namespace SabreTools.DatFiles
 
         #endregion
     }
+
+    /// <summary>
+    /// Represents a DAT that can be serialized
+    /// </summary>
+    /// <typeparam name="T">Base internal model for the DAT type</typeparam>
+    /// <typeparam name="U">IFileSerializer type to use for conversion</typeparam>
+    /// <typeparam name="V">IModelSerializer for cross-model serialization</typeparam>
+    public abstract class SerializableDatFile<T, U, V> : DatFile
+        where U : IFileSerializer<T>
+        where V : IModelSerializer<T, Models.Metadata.MetadataFile>
+    {
+        /// <inheritdoc/>
+        protected SerializableDatFile(DatFile? datFile) : base(datFile) { }
+
+        /// <inheritdoc/>
+        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
+        {
+            try
+            {
+                // Deserialize the input file in two steps
+                var specificFormat = Activator.CreateInstance<U>().Deserialize(filename);
+                var internalFormat = Activator.CreateInstance<V>().Serialize(specificFormat);
+
+                // Convert to the internal format
+                ConvertMetadata(internalFormat, filename, indexId, keep, statsOnly);
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                string message = $"'{filename}' - An error occurred during parsing";
+                logger.Error(ex, message);
+            }
+        }
+
+        /// <inheritdoc/>
+        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
+        {
+            try
+            {
+                logger.User($"Writing to '{outfile}'...");
+
+                // Serialize the input file in two steps
+                var internalFormat = ConvertMetadata(ignoreblanks);
+                var specificFormat = Activator.CreateInstance<V>().Deserialize(internalFormat);
+                if (!Activator.CreateInstance<U>().Serialize(specificFormat, outfile))
+                {
+                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
+                    return false;
+                }
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                logger.Error(ex);
+                return false;
+            }
+
+            logger.User($"'{outfile}' written!{Environment.NewLine}");
+            return true;
+        }
+    }
 }

SabreTools.DatFiles/Formats/ArchiveDotOrg.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing a Archive.org file list
-    /// </summary>
-    internal partial class ArchiveDotOrg : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var files = new Serialization.Files.ArchiveDotOrg().Deserialize(filename);
-                var metadata = new Serialization.CrossModel.ArchiveDotOrg().Serialize(files);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/ArchiveDotOrg.Writer.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.DatItems;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing and writing of a Archive.org file list
-    /// </summary>
-    internal partial class ArchiveDotOrg : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Rom,
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem) => null;
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var files = new Serialization.CrossModel.ArchiveDotOrg().Deserialize(metadata);                
-                if (!new Serialization.Files.ArchiveDotOrg().Serialize(files, outfile))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/ArchiveDotOrg.cs

@@ -1,9 +1,13 @@
-namespace SabreTools.DatFiles.Formats
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.DatItems;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents a Archive.org file list
     /// </summary>
-    internal partial class ArchiveDotOrg : DatFile
+    internal sealed class ArchiveDotOrg : SerializableDatFile<Models.ArchiveDotOrg.Files, Serialization.Files.ArchiveDotOrg, Serialization.CrossModel.ArchiveDotOrg>
     {
         /// <summary>
         /// Constructor designed for casting a base DatFile
@@ -13,5 +17,17 @@
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Rom,
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem) => null;
     }
 }

SabreTools.DatFiles/Formats/AttractMode.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing of an AttractMode DAT
-    /// </summary>
-    internal partial class AttractMode : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var metadataFile = new Serialization.Files.AttractMode().Deserialize(filename);
-                var metadata = new Serialization.CrossModel.AttractMode().Serialize(metadataFile);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/AttractMode.Writer.cs

@@ -1,60 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.DatItems;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing and writing of an AttractMode DAT
-    /// </summary>
-    internal partial class AttractMode : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Rom
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-
-            // Check item name
-            if (string.IsNullOrEmpty(datItem.GetName()))
-                missingFields.Add(Models.Metadata.Rom.NameKey);
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var metadataFile = new Serialization.CrossModel.AttractMode().Deserialize(metadata);
-                if (!(new Serialization.Files.AttractMode().Serialize(metadataFile, outfile)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/AttractMode.cs

@@ -1,9 +1,13 @@
-namespace SabreTools.DatFiles.Formats
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.DatItems;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents an AttractMode DAT
     /// </summary>
-    internal partial class AttractMode : DatFile
+    internal sealed class AttractMode : SerializableDatFile<Models.AttractMode.MetadataFile, Serialization.Files.AttractMode, Serialization.CrossModel.AttractMode>
     {
         /// <summary>
         /// Constructor designed for casting a base DatFile
@@ -13,5 +17,26 @@
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Rom
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            return missingFields;
+        }
     }
 }

SabreTools.DatFiles/Formats/ClrMamePro.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing of a ClrMamePro DAT
-    /// </summary>
-    internal partial class ClrMamePro : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var metadataFile = new Serialization.Files.ClrMamePro().Deserialize(filename, this.Quotes);
-                var metadata = new Serialization.CrossModel.ClrMamePro().Serialize(metadataFile);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/ClrMamePro.Writer.cs

@@ -1,161 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.Core.Tools;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents writing of a ClrMamePro DAT
-    /// </summary>
-    internal partial class ClrMamePro : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Archive,
-                ItemType.BiosSet,
-                ItemType.Chip,
-                ItemType.DipSwitch,
-                ItemType.Disk,
-                ItemType.Display,
-                ItemType.Driver,
-                ItemType.Input,
-                ItemType.Media,
-                ItemType.Release,
-                ItemType.Rom,
-                ItemType.Sample,
-                ItemType.Sound,
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-            switch (datItem)
-            {
-                case Release release:
-                    if (string.IsNullOrEmpty(release.GetName()))
-                        missingFields.Add(Models.Metadata.Release.NameKey);
-                    if (string.IsNullOrEmpty(release.GetStringFieldValue(Models.Metadata.Release.RegionKey)))
-                        missingFields.Add(Models.Metadata.Release.RegionKey);
-                    break;
-
-                case BiosSet biosset:
-                    if (string.IsNullOrEmpty(biosset.GetName()))
-                        missingFields.Add(Models.Metadata.BiosSet.NameKey);
-                    if (string.IsNullOrEmpty(biosset.GetStringFieldValue(Models.Metadata.BiosSet.DescriptionKey)))
-                        missingFields.Add(Models.Metadata.BiosSet.DescriptionKey);
-                    break;
-
-                case Rom rom:
-                    if (string.IsNullOrEmpty(rom.GetName()))
-                        missingFields.Add(Models.Metadata.Rom.NameKey);
-                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
-                        missingFields.Add(Models.Metadata.Rom.SizeKey);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SpamSumKey)))
-                    {
-                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                    }
-                    break;
-
-                case Disk disk:
-                    if (string.IsNullOrEmpty(disk.GetName()))
-                        missingFields.Add(Models.Metadata.Disk.NameKey);
-                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key))
-                        && string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
-                    {
-                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
-                    }
-                    break;
-
-                case Sample sample:
-                    if (string.IsNullOrEmpty(sample.GetName()))
-                        missingFields.Add(Models.Metadata.Sample.NameKey);
-                    break;
-
-                case Archive archive:
-                    if (string.IsNullOrEmpty(archive.GetName()))
-                        missingFields.Add(Models.Metadata.Archive.NameKey);
-                    break;
-
-                case Chip chip:
-                    if (chip.GetStringFieldValue(Models.Metadata.Chip.ChipTypeKey).AsEnumValue<ChipType>() == ChipType.NULL)
-                        missingFields.Add(Models.Metadata.Chip.ChipTypeKey);
-                    if (string.IsNullOrEmpty(chip.GetName()))
-                        missingFields.Add(Models.Metadata.Chip.NameKey);
-                    break;
-
-                case Display display:
-                    if (display.GetStringFieldValue(Models.Metadata.Display.DisplayTypeKey).AsEnumValue<DisplayType>() == DisplayType.NULL)
-                        missingFields.Add(Models.Metadata.Display.DisplayTypeKey);
-                    if (display.GetInt64FieldValue(Models.Metadata.Display.RotateKey) == null)
-                        missingFields.Add(Models.Metadata.Display.RotateKey);
-                    break;
-
-                case Sound sound:
-                    if (sound.GetInt64FieldValue(Models.Metadata.Sound.ChannelsKey) == null)
-                        missingFields.Add(Models.Metadata.Sound.ChannelsKey);
-                    break;
-
-                case Input input:
-                    if (input.GetInt64FieldValue(Models.Metadata.Input.PlayersKey) == null)
-                        missingFields.Add(Models.Metadata.Input.PlayersKey);
-                    if (!input.ControlsSpecified)
-                        missingFields.Add(Models.Metadata.Input.ControlKey);
-                    break;
-
-                case DipSwitch dipswitch:
-                    if (string.IsNullOrEmpty(dipswitch.GetName()))
-                        missingFields.Add(Models.Metadata.DipSwitch.NameKey);
-                    break;
-
-                case Driver driver:
-                    if (driver.GetStringFieldValue(Models.Metadata.Driver.StatusKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
-                        missingFields.Add(Models.Metadata.Driver.StatusKey);
-                    if (driver.GetStringFieldValue(Models.Metadata.Driver.EmulationKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
-                        missingFields.Add(Models.Metadata.Driver.EmulationKey);
-                    break;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var metadataFile = new Serialization.CrossModel.ClrMamePro().Deserialize(metadata);
-                if (!(new Serialization.Files.ClrMamePro().Serialize(metadataFile, outfile, Quotes)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/ClrMamePro.cs

@@ -1,9 +1,16 @@
-namespace SabreTools.DatFiles.Formats
+using System;
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.Core.Tools;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents a ClrMamePro DAT
     /// </summary>
-    internal partial class ClrMamePro : DatFile
+    internal sealed class ClrMamePro : SerializableDatFile<Models.ClrMamePro.MetadataFile, Serialization.Files.ClrMamePro, Serialization.CrossModel.ClrMamePro>
     {
         #region Fields
 
@@ -24,5 +31,170 @@
         {
             Quotes = quotes;
         }
+
+        /// <inheritdoc/>
+        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
+        {
+            try
+            {
+                // Deserialize the input file
+                var metadataFile = new Serialization.Files.ClrMamePro().Deserialize(filename, this.Quotes);
+                var metadata = new Serialization.CrossModel.ClrMamePro().Serialize(metadataFile);
+
+                // Convert to the internal format
+                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                string message = $"'{filename}' - An error occurred during parsing";
+                logger.Error(ex, message);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Archive,
+                ItemType.BiosSet,
+                ItemType.Chip,
+                ItemType.DipSwitch,
+                ItemType.Disk,
+                ItemType.Display,
+                ItemType.Driver,
+                ItemType.Input,
+                ItemType.Media,
+                ItemType.Release,
+                ItemType.Rom,
+                ItemType.Sample,
+                ItemType.Sound,
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+            switch (datItem)
+            {
+                case Release release:
+                    if (string.IsNullOrEmpty(release.GetName()))
+                        missingFields.Add(Models.Metadata.Release.NameKey);
+                    if (string.IsNullOrEmpty(release.GetStringFieldValue(Models.Metadata.Release.RegionKey)))
+                        missingFields.Add(Models.Metadata.Release.RegionKey);
+                    break;
+
+                case BiosSet biosset:
+                    if (string.IsNullOrEmpty(biosset.GetName()))
+                        missingFields.Add(Models.Metadata.BiosSet.NameKey);
+                    if (string.IsNullOrEmpty(biosset.GetStringFieldValue(Models.Metadata.BiosSet.DescriptionKey)))
+                        missingFields.Add(Models.Metadata.BiosSet.DescriptionKey);
+                    break;
+
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetName()))
+                        missingFields.Add(Models.Metadata.Rom.NameKey);
+                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
+                        missingFields.Add(Models.Metadata.Rom.SizeKey);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SpamSumKey)))
+                    {
+                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
+                    }
+                    break;
+
+                case Disk disk:
+                    if (string.IsNullOrEmpty(disk.GetName()))
+                        missingFields.Add(Models.Metadata.Disk.NameKey);
+                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key))
+                        && string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
+                    {
+                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
+                    }
+                    break;
+
+                case Sample sample:
+                    if (string.IsNullOrEmpty(sample.GetName()))
+                        missingFields.Add(Models.Metadata.Sample.NameKey);
+                    break;
+
+                case Archive archive:
+                    if (string.IsNullOrEmpty(archive.GetName()))
+                        missingFields.Add(Models.Metadata.Archive.NameKey);
+                    break;
+
+                case Chip chip:
+                    if (chip.GetStringFieldValue(Models.Metadata.Chip.ChipTypeKey).AsEnumValue<ChipType>() == ChipType.NULL)
+                        missingFields.Add(Models.Metadata.Chip.ChipTypeKey);
+                    if (string.IsNullOrEmpty(chip.GetName()))
+                        missingFields.Add(Models.Metadata.Chip.NameKey);
+                    break;
+
+                case Display display:
+                    if (display.GetStringFieldValue(Models.Metadata.Display.DisplayTypeKey).AsEnumValue<DisplayType>() == DisplayType.NULL)
+                        missingFields.Add(Models.Metadata.Display.DisplayTypeKey);
+                    if (display.GetInt64FieldValue(Models.Metadata.Display.RotateKey) == null)
+                        missingFields.Add(Models.Metadata.Display.RotateKey);
+                    break;
+
+                case Sound sound:
+                    if (sound.GetInt64FieldValue(Models.Metadata.Sound.ChannelsKey) == null)
+                        missingFields.Add(Models.Metadata.Sound.ChannelsKey);
+                    break;
+
+                case Input input:
+                    if (input.GetInt64FieldValue(Models.Metadata.Input.PlayersKey) == null)
+                        missingFields.Add(Models.Metadata.Input.PlayersKey);
+                    if (!input.ControlsSpecified)
+                        missingFields.Add(Models.Metadata.Input.ControlKey);
+                    break;
+
+                case DipSwitch dipswitch:
+                    if (string.IsNullOrEmpty(dipswitch.GetName()))
+                        missingFields.Add(Models.Metadata.DipSwitch.NameKey);
+                    break;
+
+                case Driver driver:
+                    if (driver.GetStringFieldValue(Models.Metadata.Driver.StatusKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
+                        missingFields.Add(Models.Metadata.Driver.StatusKey);
+                    if (driver.GetStringFieldValue(Models.Metadata.Driver.EmulationKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
+                        missingFields.Add(Models.Metadata.Driver.EmulationKey);
+                    break;
+            }
+
+            return missingFields;
+        }
+
+        /// <inheritdoc/>
+        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
+        {
+            try
+            {
+                logger.User($"Writing to '{outfile}'...");
+
+                // Serialize the input file
+                var metadata = ConvertMetadata(ignoreblanks);
+                var metadataFile = new Serialization.CrossModel.ClrMamePro().Deserialize(metadata);
+                if (!(new Serialization.Files.ClrMamePro().Serialize(metadataFile, outfile, Quotes)))
+                {
+                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
+                    return false;
+                }
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                logger.Error(ex);
+                return false;
+            }
+
+            logger.User($"'{outfile}' written!{Environment.NewLine}");
+            return true;
+        }
     }
 }

SabreTools.DatFiles/Formats/DosCenter.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing and writing of a DosCenter DAT
-    /// </summary>
-    internal partial class DosCenter : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var metadataFile = new Serialization.Files.DosCenter().Deserialize(filename);
-                var metadata = new Serialization.CrossModel.DosCenter().Serialize(metadataFile);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/DosCenter.Writer.cs

@@ -1,73 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing and writing of a DosCenter DAT
-    /// </summary>
-    internal partial class DosCenter : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Rom
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-
-            // Check item name
-            if (string.IsNullOrEmpty(datItem.GetName()))
-                missingFields.Add(Models.Metadata.Rom.NameKey);
-
-            switch (datItem)
-            {
-                case Rom rom:
-                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
-                        missingFields.Add(Models.Metadata.Rom.SizeKey);
-                    // if (string.IsNullOrEmpty(rom.Date))
-                    //     missingFields.Add(Models.Metadata.Rom.DateKey);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
-                        missingFields.Add(Models.Metadata.Rom.CRCKey);
-                    break;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var metadataFile = new Serialization.CrossModel.DosCenter().Deserialize(metadata);
-                if (!(new Serialization.Files.DosCenter().Serialize(metadataFile, outfile)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/DosCenter.cs

@@ -1,9 +1,14 @@
-namespace SabreTools.DatFiles.Formats
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
-    /// Represents a DosCenter DAT
+    /// Represents parsing and writing of a DosCenter DAT
     /// </summary>
-    internal partial class DosCenter : DatFile
+    internal sealed class DosCenter : SerializableDatFile<Models.DosCenter.MetadataFile, Serialization.Files.DosCenter, Serialization.CrossModel.DosCenter>
     {
         /// <summary>
         /// Constructor designed for casting a base DatFile
@@ -13,5 +18,38 @@
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Rom
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Rom rom:
+                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
+                        missingFields.Add(Models.Metadata.Rom.SizeKey);
+                    // if (string.IsNullOrEmpty(rom.Date))
+                    //     missingFields.Add(Models.Metadata.Rom.DateKey);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
+                        missingFields.Add(Models.Metadata.Rom.CRCKey);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 }

SabreTools.DatFiles/Formats/EverdriveSMDB.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing and writing of an Everdrive SMDB file
-    /// </summary>
-    internal partial class EverdriveSMDB : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var metadataFile = new Serialization.Files.EverdriveSMDB().Deserialize(filename);
-                var metadata = new Serialization.CrossModel.EverdriveSMDB().Serialize(metadataFile);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/EverdriveSMDB.Writer.cs

@@ -1,77 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing and writing of an Everdrive SMDB file
-    /// </summary>
-    internal partial class EverdriveSMDB : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Rom
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-
-            // Check item name
-            if (string.IsNullOrEmpty(datItem.GetName()))
-                missingFields.Add(Models.Metadata.Rom.NameKey);
-
-            switch (datItem)
-            {
-                case Rom rom:
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key)))
-                        missingFields.Add(Models.Metadata.Rom.SHA256Key);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
-                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key)))
-                        missingFields.Add(Models.Metadata.Rom.MD5Key);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
-                        missingFields.Add(Models.Metadata.Rom.CRCKey);
-                    break;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                //var metadataFile = CreateMetadataFile(ignoreblanks);
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var metadataFile = new Serialization.CrossModel.EverdriveSMDB().Deserialize(metadata);
-                if (!(new Serialization.Files.EverdriveSMDB().Serialize(metadataFile, outfile)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/EverdriveSmdb.cs

@@ -1,9 +1,14 @@
-namespace SabreTools.DatFiles.Formats
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents parsing and writing of an Everdrive SMDB file
     /// </summary>
-    internal partial class EverdriveSMDB : DatFile
+    internal sealed class EverdriveSMDB : SerializableDatFile<Models.EverdriveSMDB.MetadataFile, Serialization.Files.EverdriveSMDB, Serialization.CrossModel.EverdriveSMDB>
     {
         /// <summary>
         /// Constructor designed for casting a base DatFile
@@ -13,5 +18,40 @@
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Rom
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key)))
+                        missingFields.Add(Models.Metadata.Rom.SHA256Key);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
+                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key)))
+                        missingFields.Add(Models.Metadata.Rom.MD5Key);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
+                        missingFields.Add(Models.Metadata.Rom.CRCKey);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 }

SabreTools.DatFiles/Formats/Hashfile.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing of a hashfile such as an SFV, MD5, or SHA-1 file
-    /// </summary>
-    internal partial class Hashfile : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var hashfile = new Serialization.Files.Hashfile().Deserialize(filename, _hash);
-                var metadata = new Serialization.CrossModel.Hashfile().Serialize(hashfile);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/Hashfile.Writer.cs

@@ -1,176 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents writing a hashfile such as an SFV, MD5, or SHA-1 file
-    /// </summary>
-    internal partial class Hashfile : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Disk,
-                ItemType.Media,
-                ItemType.Rom
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-
-            // Check item name
-            if (string.IsNullOrEmpty(datItem.GetName()))
-                missingFields.Add(Models.Metadata.Rom.NameKey);
-
-            // Check hash linked to specific Hashfile type
-            switch (_hash)
-            {
-                case Serialization.Hash.CRC:
-                    switch (datItem)
-                    {
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
-                                missingFields.Add(Models.Metadata.Rom.CRCKey);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.CRCKey);
-                            break;
-                    }
-                    break;
-                case Serialization.Hash.MD5:
-                    switch (datItem)
-                    {
-                        case Disk disk:
-                            if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key)))
-                                missingFields.Add(Models.Metadata.Disk.MD5Key);
-                            break;
-                        case Media medium:
-                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.MD5Key)))
-                                missingFields.Add(Models.Metadata.Media.MD5Key);
-                            break;
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key)))
-                                missingFields.Add(Models.Metadata.Rom.MD5Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.MD5Key);
-                            break;
-                    }
-                    break;
-                case Serialization.Hash.SHA1:
-                    switch (datItem)
-                    {
-                        case Disk disk:
-                            if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
-                                missingFields.Add(Models.Metadata.Disk.SHA1Key);
-                            break;
-                        case Media medium:
-                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SHA1Key)))
-                                missingFields.Add(Models.Metadata.Media.SHA1Key);
-                            break;
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
-                                missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                            break;
-                    }
-                    break;
-                case Serialization.Hash.SHA256:
-                    switch (datItem)
-                    {
-                        case Media medium:
-                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SHA256Key)))
-                                missingFields.Add(Models.Metadata.Media.SHA256Key);
-                            break;
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key)))
-                                missingFields.Add(Models.Metadata.Rom.SHA256Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.SHA256Key);
-                            break;
-                    }
-                    break;
-                case Serialization.Hash.SHA384:
-                    switch (datItem)
-                    {
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key)))
-                                missingFields.Add(Models.Metadata.Rom.SHA384Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.SHA384Key);
-                            break;
-                    }
-                    break;
-                case Serialization.Hash.SHA512:
-                    switch (datItem)
-                    {
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key)))
-                                missingFields.Add(Models.Metadata.Rom.SHA512Key);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.SHA512Key);
-                            break;
-                    }
-                    break;
-                case Serialization.Hash.SpamSum:
-                    switch (datItem)
-                    {
-                        case Media medium:
-                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SpamSumKey)))
-                                missingFields.Add(Models.Metadata.Media.SpamSumKey);
-                            break;
-                        case Rom rom:
-                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SpamSumKey)))
-                                missingFields.Add(Models.Metadata.Rom.SpamSumKey);
-                            break;
-                        default:
-                            missingFields.Add(Models.Metadata.Rom.SpamSumKey);
-                            break;
-                    }
-                    break;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var hashfile = new Serialization.CrossModel.Hashfile().Deserialize(metadata, _hash);
-                if (!(new Serialization.Files.Hashfile().Serialize(hashfile, outfile, _hash)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/Hashfile.cs

@@ -1,11 +1,16 @@
-using SabreTools.Hashing;
+using System;
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+using SabreTools.Hashing;
 
 namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents a hashfile such as an SFV, MD5, or SHA-1 file
     /// </summary>
-    internal partial class Hashfile : DatFile
+    internal sealed class Hashfile : SerializableDatFile<Models.Hashfile.Hashfile, Serialization.Files.Hashfile, Serialization.CrossModel.Hashfile>
     {
         // Private instance variables specific to Hashfile DATs
         private readonly Serialization.Hash _hash;
@@ -38,5 +43,186 @@ namespace SabreTools.DatFiles.Formats
                 _ => throw new System.ArgumentOutOfRangeException(nameof(hash)),
             };
         }
+
+        /// <inheritdoc/>
+        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
+        {
+            try
+            {
+                // Deserialize the input file
+                var hashfile = new Serialization.Files.Hashfile().Deserialize(filename, _hash);
+                var metadata = new Serialization.CrossModel.Hashfile().Serialize(hashfile);
+
+                // Convert to the internal format
+                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                string message = $"'{filename}' - An error occurred during parsing";
+                logger.Error(ex, message);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Disk,
+                ItemType.Media,
+                ItemType.Rom
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            // Check hash linked to specific Hashfile type
+            switch (_hash)
+            {
+                case Serialization.Hash.CRC:
+                    switch (datItem)
+                    {
+                        case Rom rom:
+                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
+                                missingFields.Add(Models.Metadata.Rom.CRCKey);
+                            break;
+                        default:
+                            missingFields.Add(Models.Metadata.Rom.CRCKey);
+                            break;
+                    }
+                    break;
+                case Serialization.Hash.MD5:
+                    switch (datItem)
+                    {
+                        case Disk disk:
+                            if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key)))
+                                missingFields.Add(Models.Metadata.Disk.MD5Key);
+                            break;
+                        case Media medium:
+                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.MD5Key)))
+                                missingFields.Add(Models.Metadata.Media.MD5Key);
+                            break;
+                        case Rom rom:
+                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key)))
+                                missingFields.Add(Models.Metadata.Rom.MD5Key);
+                            break;
+                        default:
+                            missingFields.Add(Models.Metadata.Rom.MD5Key);
+                            break;
+                    }
+                    break;
+                case Serialization.Hash.SHA1:
+                    switch (datItem)
+                    {
+                        case Disk disk:
+                            if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
+                                missingFields.Add(Models.Metadata.Disk.SHA1Key);
+                            break;
+                        case Media medium:
+                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SHA1Key)))
+                                missingFields.Add(Models.Metadata.Media.SHA1Key);
+                            break;
+                        case Rom rom:
+                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
+                                missingFields.Add(Models.Metadata.Rom.SHA1Key);
+                            break;
+                        default:
+                            missingFields.Add(Models.Metadata.Rom.SHA1Key);
+                            break;
+                    }
+                    break;
+                case Serialization.Hash.SHA256:
+                    switch (datItem)
+                    {
+                        case Media medium:
+                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SHA256Key)))
+                                missingFields.Add(Models.Metadata.Media.SHA256Key);
+                            break;
+                        case Rom rom:
+                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key)))
+                                missingFields.Add(Models.Metadata.Rom.SHA256Key);
+                            break;
+                        default:
+                            missingFields.Add(Models.Metadata.Rom.SHA256Key);
+                            break;
+                    }
+                    break;
+                case Serialization.Hash.SHA384:
+                    switch (datItem)
+                    {
+                        case Rom rom:
+                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key)))
+                                missingFields.Add(Models.Metadata.Rom.SHA384Key);
+                            break;
+                        default:
+                            missingFields.Add(Models.Metadata.Rom.SHA384Key);
+                            break;
+                    }
+                    break;
+                case Serialization.Hash.SHA512:
+                    switch (datItem)
+                    {
+                        case Rom rom:
+                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key)))
+                                missingFields.Add(Models.Metadata.Rom.SHA512Key);
+                            break;
+                        default:
+                            missingFields.Add(Models.Metadata.Rom.SHA512Key);
+                            break;
+                    }
+                    break;
+                case Serialization.Hash.SpamSum:
+                    switch (datItem)
+                    {
+                        case Media medium:
+                            if (string.IsNullOrEmpty(medium.GetStringFieldValue(Models.Metadata.Media.SpamSumKey)))
+                                missingFields.Add(Models.Metadata.Media.SpamSumKey);
+                            break;
+                        case Rom rom:
+                            if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SpamSumKey)))
+                                missingFields.Add(Models.Metadata.Rom.SpamSumKey);
+                            break;
+                        default:
+                            missingFields.Add(Models.Metadata.Rom.SpamSumKey);
+                            break;
+                    }
+                    break;
+            }
+
+            return missingFields;
+        }
+
+        /// <inheritdoc/>
+        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
+        {
+            try
+            {
+                logger.User($"Writing to '{outfile}'...");
+
+                // Serialize the input file
+                var metadata = ConvertMetadata(ignoreblanks);
+                var hashfile = new Serialization.CrossModel.Hashfile().Deserialize(metadata, _hash);
+                if (!(new Serialization.Files.Hashfile().Serialize(hashfile, outfile, _hash)))
+                {
+                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
+                    return false;
+                }
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                logger.Error(ex);
+                return false;
+            }
+
+            logger.User($"'{outfile}' written!{Environment.NewLine}");
+            return true;
+        }
     }
 }

SabreTools.DatFiles/Formats/Listrom.Reader.cs

@@ -1,222 +0,0 @@
-using System;
-using System.Linq;
-using SabreTools.Core;
-using SabreTools.Core.Tools;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-// TODO: When Serialization is updated, this should work as there was a bug in the library
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing a MAME Listrom file
-    /// </summary>
-    internal partial class Listrom : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var metadataFile = new Serialization.Files.Listrom().Deserialize(filename);
-
-                // Convert the set data to the internal format
-                ConvertSets(metadataFile?.Set, filename, indexId, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-
-        #region Converters
-
-        /// <summary>
-        /// Convert sets information
-        /// </summary>
-        /// <param name="sets">Array of deserialized models to convert</param>
-        /// <param name="filename">Name of the file to be parsed</param>
-        /// <param name="indexId">Index ID for the DAT</param>
-        /// <param name="statsOnly">True to only add item statistics while parsing, false otherwise</param>
-        private void ConvertSets(Models.Listrom.Set[]? sets, string filename, int indexId, bool statsOnly)
-        {
-            // If the rows array is missing, we can't do anything
-            if (sets == null || !sets.Any())
-                return;
-
-            // Loop through the sets and add
-            foreach (var set in sets)
-            {
-                ConvertSet(set, filename, indexId, statsOnly);
-            }
-        }
-
-        /// <summary>
-        /// Convert set information
-        /// </summary>
-        /// <param name="set">Deserialized model to convert</param>
-        /// <param name="filename">Name of the file to be parsed</param>
-        /// <param name="indexId">Index ID for the DAT</param>
-        /// <param name="statsOnly">True to only add item statistics while parsing, false otherwise</param>
-        private void ConvertSet(Models.Listrom.Set? set, string filename, int indexId, bool statsOnly)
-        {
-            // If the set is missing, we can't do anything
-            if (set == null)
-                return;
-
-            // Create the machine
-            Machine machine;
-            if (!string.IsNullOrEmpty(set.Device))
-            {
-                machine = new Machine();
-                machine.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, set.Device);
-                machine.SetFieldValue<string?>(Models.Metadata.Machine.IsDeviceKey, (true as bool?).FromYesNo());
-            }
-            else if (!string.IsNullOrEmpty(set.Driver))
-            {
-                machine = new Machine();
-                machine.SetFieldValue<string?>(Models.Metadata.Machine.NameKey, set.Driver);
-            }
-            else
-            {
-                return;
-            }
-
-            foreach (var row in set.Row ?? [])
-            {
-                ConvertRow(row, machine, filename, indexId, statsOnly);
-            }
-        }
-
-        /// <summary>
-        /// Convert row information
-        /// </summary>
-        /// <param name="row">Deserialized model to convert</param>
-        /// <param name="filename">Name of the file to be parsed</param>
-        /// <param name="indexId">Index ID for the DAT</param>
-        /// <param name="statsOnly">True to only add item statistics while parsing, false otherwise</param>
-        private void ConvertRow(Models.Listrom.Row? row, Machine machine, string filename, int indexId, bool statsOnly)
-        {
-            // If the row is missing, we can't do anything
-            if (row == null)
-                return;
-
-            // Normal CHD
-            if (row.Size == null
-                && !row.NoGoodDumpKnown
-                && !row.Bad
-                && (!string.IsNullOrEmpty(row.MD5)
-                    || !string.IsNullOrEmpty(row.SHA1)))
-            {
-                var disk = new Disk();
-                disk.SetName(row.Name);
-                disk.SetFieldValue<string?>(Models.Metadata.Disk.StatusKey, ItemStatus.None.AsStringValue());
-                disk.SetFieldValue<Source?>(DatItem.SourceKey, new Source { Index = indexId, Name = filename });
-
-                if (!string.IsNullOrEmpty(row.MD5))
-                    disk.SetFieldValue<string?>(Models.Metadata.Disk.MD5Key, row.MD5);
-                else
-                    disk.SetFieldValue<string?>(Models.Metadata.Disk.SHA1Key, row.SHA1);
-
-                // Now process and add the item
-                disk.CopyMachineInformation(machine);
-                ParseAddHelper(disk, statsOnly);
-            }
-
-            // Normal ROM
-            else if (row.Size != null
-                && !row.NoGoodDumpKnown
-                && !row.Bad)
-            {
-                var rom = new Rom();
-                rom.SetName(row.Name);
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, row.CRC);
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, row.SHA1);
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, NumberHelper.ConvertToInt64(row.Size).ToString());
-                rom.SetFieldValue<Source?>(DatItem.SourceKey, new Source { Index = indexId, Name = filename });
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.StatusKey, ItemStatus.None.AsStringValue());
-
-                // Now process and add the item
-                rom.CopyMachineInformation(machine);
-                ParseAddHelper(rom, statsOnly);
-            }
-
-            // Bad CHD
-            else if (row.Size == null
-                && !row.NoGoodDumpKnown
-                && row.Bad
-                && (!string.IsNullOrEmpty(row.MD5)
-                    || !string.IsNullOrEmpty(row.SHA1)))
-            {
-                var disk = new Disk();
-                disk.SetName(row.Name);
-                disk.SetFieldValue<string?>(Models.Metadata.Disk.StatusKey, ItemStatus.BadDump.AsStringValue());
-                disk.SetFieldValue<Source?>(DatItem.SourceKey, new Source { Index = indexId, Name = filename });
-
-                if (!string.IsNullOrEmpty(row.MD5))
-                    disk.SetFieldValue<string?>(Models.Metadata.Disk.MD5Key, row.MD5);
-                else
-                    disk.SetFieldValue<string?>(Models.Metadata.Disk.SHA1Key, row.SHA1);
-
-                // Now process and add the item
-                disk.CopyMachineInformation(machine);
-                ParseAddHelper(disk, statsOnly);
-            }
-
-            // Nodump CHD
-            else if (row.Size == null
-                && row.NoGoodDumpKnown)
-            {
-                var disk = new Disk();
-                disk.SetName(row.Name);
-                disk.SetFieldValue<string?>(Models.Metadata.Disk.MD5Key, null);
-                disk.SetFieldValue<string?>(Models.Metadata.Disk.SHA1Key, null);
-                disk.SetFieldValue<Source?>(DatItem.SourceKey, new Source { Index = indexId, Name = filename });
-                disk.SetFieldValue<string?>(Models.Metadata.Disk.StatusKey, ItemStatus.Nodump.AsStringValue());
-
-                // Now process and add the item
-                disk.CopyMachineInformation(machine);
-                ParseAddHelper(disk, statsOnly);
-            }
-
-            // Bad ROM
-            else if (row.Size != null
-                && !row.NoGoodDumpKnown
-                && row.Bad)
-            {
-                var rom = new Rom();
-                rom.SetName(row.Name);
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, row.CRC);
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, row.SHA1);
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, NumberHelper.ConvertToInt64(row.Size).ToString());
-                rom.SetFieldValue<Source?>(DatItem.SourceKey, new Source { Index = indexId, Name = filename });
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.StatusKey, ItemStatus.BadDump.AsStringValue());
-
-                // Now process and add the item
-                rom.CopyMachineInformation(machine);
-                ParseAddHelper(rom, statsOnly);
-            }
-
-            // Nodump ROM
-            else if (row.Size != null
-                && row.NoGoodDumpKnown)
-            {
-                var rom = new Rom();
-                rom.SetName(row.Name);
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.CRCKey, null);
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.SHA1Key, null);
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.SizeKey, NumberHelper.ConvertToInt64(row.Size).ToString());
-                rom.SetFieldValue<Source?>(DatItem.SourceKey, new Source { Index = indexId, Name = filename });
-                rom.SetFieldValue<string?>(Models.Metadata.Rom.StatusKey, ItemStatus.Nodump.AsStringValue());
-
-                // Now process and add the item
-                rom.CopyMachineInformation(machine);
-                ParseAddHelper(rom, statsOnly);
-            }
-        }
-
-        #endregion
-    }
-}

SabreTools.DatFiles/Formats/Listrom.Writer.cs

@@ -1,82 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents writing a MAME Listrom file
-    /// </summary>
-    internal partial class Listrom : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Disk,
-                ItemType.Rom
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-
-            // Check item name
-            if (string.IsNullOrEmpty(datItem.GetName()))
-                missingFields.Add(Models.Metadata.Rom.NameKey);
-
-            switch (datItem)
-            {
-                case Disk disk:
-                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key))
-                        && string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
-                    {
-                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
-                    }
-                    break;
-
-                case Rom rom:
-                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
-                        missingFields.Add(Models.Metadata.Rom.SizeKey);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
-                        missingFields.Add(Models.Metadata.Rom.CRCKey);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
-                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                    break;
-            }
-
-            return null;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var metadataFile = new Serialization.CrossModel.Listrom().Deserialize(metadata);
-                if (!(new Serialization.Files.Listrom().Serialize(metadataFile, outfile)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/Listrom.cs

@@ -1,9 +1,14 @@
-namespace SabreTools.DatFiles.Formats
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents a MAME Listrom file
     /// </summary>
-    internal partial class Listrom : DatFile
+    internal sealed class Listrom : SerializableDatFile<Models.Listrom.MetadataFile, Serialization.Files.Listrom, Serialization.CrossModel.Listrom>
     {
         /// <summary>
         /// Constructor designed for casting a base DatFile
@@ -13,5 +18,47 @@
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Disk,
+                ItemType.Rom
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Disk disk:
+                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key))
+                        && string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
+                    {
+                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
+                    }
+                    break;
+
+                case Rom rom:
+                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
+                        missingFields.Add(Models.Metadata.Rom.SizeKey);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
+                        missingFields.Add(Models.Metadata.Rom.CRCKey);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
+                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
+                    break;
+            }
+
+            return null;
+        }
     }
 }

SabreTools.DatFiles/Formats/Listxml.Reader.cs

@@ -1,38 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing a MAME XML DAT
-    /// </summary>
-    internal partial class Listxml : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var mame = new Serialization.Files.Listxml().Deserialize(filename);
-                Models.Metadata.MetadataFile? metadata;
-                if (mame == null)
-                {
-                    var m1 = new Serialization.Files.M1().Deserialize(filename);
-                    metadata = new Serialization.CrossModel.M1().Serialize(m1);
-                }
-                else
-                {
-                    metadata = new Serialization.CrossModel.Listxml().Serialize(mame);
-                }
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/Listxml.Writer.cs

@@ -1,206 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.Core.Tools;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents writing a MAME XML DAT
-    /// </summary>
-    internal partial class Listxml : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Adjuster,
-                ItemType.BiosSet,
-                ItemType.Chip,
-                ItemType.Condition,
-                ItemType.Configuration,
-                ItemType.Device,
-                ItemType.DeviceRef,
-                ItemType.DipSwitch,
-                ItemType.Disk,
-                ItemType.Display,
-                ItemType.Driver,
-                ItemType.Feature,
-                ItemType.Input,
-                ItemType.Port,
-                ItemType.RamOption,
-                ItemType.Rom,
-                ItemType.Sample,
-                ItemType.Slot,
-                ItemType.SoftwareList,
-                ItemType.Sound,
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-            switch (datItem)
-            {
-                case BiosSet biosset:
-                    if (string.IsNullOrEmpty(biosset.GetName()))
-                        missingFields.Add(Models.Metadata.BiosSet.NameKey);
-                    if (string.IsNullOrEmpty(biosset.GetStringFieldValue(Models.Metadata.BiosSet.DescriptionKey)))
-                        missingFields.Add(Models.Metadata.BiosSet.DescriptionKey);
-                    break;
-
-                case Rom rom:
-                    if (string.IsNullOrEmpty(rom.GetName()))
-                        missingFields.Add(Models.Metadata.Rom.NameKey);
-                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
-                        missingFields.Add(Models.Metadata.Rom.SizeKey);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
-                    {
-                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                    }
-                    break;
-
-                case Disk disk:
-                    if (string.IsNullOrEmpty(disk.GetName()))
-                        missingFields.Add(Models.Metadata.Disk.NameKey);
-                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key))
-                        && string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
-                    {
-                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
-                    }
-                    break;
-
-                case DeviceRef deviceref:
-                    if (string.IsNullOrEmpty(deviceref.GetName()))
-                        missingFields.Add(Models.Metadata.DeviceRef.NameKey);
-                    break;
-
-                case Sample sample:
-                    if (string.IsNullOrEmpty(sample.GetName()))
-                        missingFields.Add(Models.Metadata.Sample.NameKey);
-                    break;
-
-                case Chip chip:
-                    if (string.IsNullOrEmpty(chip.GetName()))
-                        missingFields.Add(Models.Metadata.Chip.NameKey);
-                    if (chip.GetStringFieldValue(Models.Metadata.Chip.ChipTypeKey).AsEnumValue<ChipType>() == ChipType.NULL)
-                        missingFields.Add(Models.Metadata.Chip.ChipTypeKey);
-                    break;
-
-                case Display display:
-                    if (display.GetStringFieldValue(Models.Metadata.Display.DisplayTypeKey).AsEnumValue<DisplayType>() == DisplayType.NULL)
-                        missingFields.Add(Models.Metadata.Display.DisplayTypeKey);
-                    if (display.GetDoubleFieldValue(Models.Metadata.Display.RefreshKey) == null)
-                        missingFields.Add(Models.Metadata.Display.RefreshKey);
-                    break;
-
-                case Sound sound:
-                    if (sound.GetInt64FieldValue(Models.Metadata.Sound.ChannelsKey) == null)
-                        missingFields.Add(Models.Metadata.Sound.ChannelsKey);
-                    break;
-
-                case Input input:
-                    if (input.GetInt64FieldValue(Models.Metadata.Input.PlayersKey) == null)
-                        missingFields.Add(Models.Metadata.Input.PlayersKey);
-                    break;
-
-                case DipSwitch dipswitch:
-                    if (string.IsNullOrEmpty(dipswitch.GetName()))
-                        missingFields.Add(Models.Metadata.DipSwitch.NameKey);
-                    if (string.IsNullOrEmpty(dipswitch.GetStringFieldValue(Models.Metadata.DipSwitch.TagKey)))
-                        missingFields.Add(Models.Metadata.DipSwitch.TagKey);
-                    break;
-
-                case Configuration configuration:
-                    if (string.IsNullOrEmpty(configuration.GetName()))
-                        missingFields.Add(Models.Metadata.Configuration.NameKey);
-                    if (string.IsNullOrEmpty(configuration.GetStringFieldValue(Models.Metadata.Configuration.TagKey)))
-                        missingFields.Add(Models.Metadata.Configuration.TagKey);
-                    break;
-
-                case Port port:
-                    if (string.IsNullOrEmpty(port.GetStringFieldValue(Models.Metadata.Port.TagKey)))
-                        missingFields.Add(Models.Metadata.Port.TagKey);
-                    break;
-
-                case Adjuster adjuster:
-                    if (string.IsNullOrEmpty(adjuster.GetName()))
-                        missingFields.Add(Models.Metadata.Adjuster.NameKey);
-                    break;
-
-                case Driver driver:
-                    if (driver.GetStringFieldValue(Models.Metadata.Driver.StatusKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
-                        missingFields.Add(Models.Metadata.Driver.StatusKey);
-                    if (driver.GetStringFieldValue(Models.Metadata.Driver.EmulationKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
-                        missingFields.Add(Models.Metadata.Driver.EmulationKey);
-                    if (driver.GetStringFieldValue(Models.Metadata.Driver.CocktailKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
-                        missingFields.Add(Models.Metadata.Driver.CocktailKey);
-                    if (driver.GetStringFieldValue(Models.Metadata.Driver.SaveStateKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
-                        missingFields.Add(Models.Metadata.Driver.SaveStateKey);
-                    break;
-
-                case Feature feature:
-                    if (feature.GetStringFieldValue(Models.Metadata.Feature.FeatureTypeKey).AsEnumValue<FeatureType>() == FeatureType.NULL)
-                        missingFields.Add(Models.Metadata.Feature.FeatureTypeKey);
-                    break;
-
-                case Device device:
-                    if (device.GetStringFieldValue(Models.Metadata.Device.DeviceTypeKey).AsEnumValue<DeviceType>() != DeviceType.NULL)
-                        missingFields.Add(Models.Metadata.Device.DeviceTypeKey);
-                    break;
-
-                case Slot slot:
-                    if (string.IsNullOrEmpty(slot.GetName()))
-                        missingFields.Add(Models.Metadata.Slot.NameKey);
-                    break;
-
-                case DatItems.Formats.SoftwareList softwarelist:
-                    if (string.IsNullOrEmpty(softwarelist.GetStringFieldValue(Models.Metadata.SoftwareList.TagKey)))
-                        missingFields.Add(Models.Metadata.SoftwareList.TagKey);
-                    if (string.IsNullOrEmpty(softwarelist.GetName()))
-                        missingFields.Add(Models.Metadata.SoftwareList.NameKey);
-                    if (softwarelist.GetStringFieldValue(Models.Metadata.SoftwareList.StatusKey).AsEnumValue<SoftwareListStatus>() == SoftwareListStatus.None)
-                        missingFields.Add(Models.Metadata.SoftwareList.StatusKey);
-                    break;
-
-                case RamOption ramoption:
-                    if (string.IsNullOrEmpty(ramoption.GetName()))
-                        missingFields.Add(Models.Metadata.RamOption.NameKey);
-                    break;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var mame = new Serialization.CrossModel.Listxml().Deserialize(metadata);
-                if (!(new Serialization.Files.Listxml().Serialize(mame, outfile)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/Listxml.cs

@@ -1,9 +1,16 @@
-namespace SabreTools.DatFiles.Formats
+using System;
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.Core.Tools;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
-    /// Represents a MAME XML DAT
+    /// Represents a MAME/M1 XML DAT
     /// </summary>
-    internal partial class Listxml : DatFile
+    internal sealed class Listxml : SerializableDatFile<Models.Listxml.Mame, Serialization.Files.Listxml, Serialization.CrossModel.Listxml>
     {
         /// <summary>
         /// DTD for original MAME XML DATs
@@ -179,5 +186,198 @@
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
+        {
+            try
+            {
+                // Deserialize the input file
+                var mame = new Serialization.Files.Listxml().Deserialize(filename);
+                Models.Metadata.MetadataFile? metadata;
+                if (mame == null)
+                {
+                    var m1 = new Serialization.Files.M1().Deserialize(filename);
+                    metadata = new Serialization.CrossModel.M1().Serialize(m1);
+                }
+                else
+                {
+                    metadata = new Serialization.CrossModel.Listxml().Serialize(mame);
+                }
+
+                // Convert to the internal format
+                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                string message = $"'{filename}' - An error occurred during parsing";
+                logger.Error(ex, message);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Adjuster,
+                ItemType.BiosSet,
+                ItemType.Chip,
+                ItemType.Condition,
+                ItemType.Configuration,
+                ItemType.Device,
+                ItemType.DeviceRef,
+                ItemType.DipSwitch,
+                ItemType.Disk,
+                ItemType.Display,
+                ItemType.Driver,
+                ItemType.Feature,
+                ItemType.Input,
+                ItemType.Port,
+                ItemType.RamOption,
+                ItemType.Rom,
+                ItemType.Sample,
+                ItemType.Slot,
+                ItemType.SoftwareList,
+                ItemType.Sound,
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+            switch (datItem)
+            {
+                case BiosSet biosset:
+                    if (string.IsNullOrEmpty(biosset.GetName()))
+                        missingFields.Add(Models.Metadata.BiosSet.NameKey);
+                    if (string.IsNullOrEmpty(biosset.GetStringFieldValue(Models.Metadata.BiosSet.DescriptionKey)))
+                        missingFields.Add(Models.Metadata.BiosSet.DescriptionKey);
+                    break;
+
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetName()))
+                        missingFields.Add(Models.Metadata.Rom.NameKey);
+                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
+                        missingFields.Add(Models.Metadata.Rom.SizeKey);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
+                    {
+                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
+                    }
+                    break;
+
+                case Disk disk:
+                    if (string.IsNullOrEmpty(disk.GetName()))
+                        missingFields.Add(Models.Metadata.Disk.NameKey);
+                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key))
+                        && string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
+                    {
+                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
+                    }
+                    break;
+
+                case DeviceRef deviceref:
+                    if (string.IsNullOrEmpty(deviceref.GetName()))
+                        missingFields.Add(Models.Metadata.DeviceRef.NameKey);
+                    break;
+
+                case Sample sample:
+                    if (string.IsNullOrEmpty(sample.GetName()))
+                        missingFields.Add(Models.Metadata.Sample.NameKey);
+                    break;
+
+                case Chip chip:
+                    if (string.IsNullOrEmpty(chip.GetName()))
+                        missingFields.Add(Models.Metadata.Chip.NameKey);
+                    if (chip.GetStringFieldValue(Models.Metadata.Chip.ChipTypeKey).AsEnumValue<ChipType>() == ChipType.NULL)
+                        missingFields.Add(Models.Metadata.Chip.ChipTypeKey);
+                    break;
+
+                case Display display:
+                    if (display.GetStringFieldValue(Models.Metadata.Display.DisplayTypeKey).AsEnumValue<DisplayType>() == DisplayType.NULL)
+                        missingFields.Add(Models.Metadata.Display.DisplayTypeKey);
+                    if (display.GetDoubleFieldValue(Models.Metadata.Display.RefreshKey) == null)
+                        missingFields.Add(Models.Metadata.Display.RefreshKey);
+                    break;
+
+                case Sound sound:
+                    if (sound.GetInt64FieldValue(Models.Metadata.Sound.ChannelsKey) == null)
+                        missingFields.Add(Models.Metadata.Sound.ChannelsKey);
+                    break;
+
+                case Input input:
+                    if (input.GetInt64FieldValue(Models.Metadata.Input.PlayersKey) == null)
+                        missingFields.Add(Models.Metadata.Input.PlayersKey);
+                    break;
+
+                case DipSwitch dipswitch:
+                    if (string.IsNullOrEmpty(dipswitch.GetName()))
+                        missingFields.Add(Models.Metadata.DipSwitch.NameKey);
+                    if (string.IsNullOrEmpty(dipswitch.GetStringFieldValue(Models.Metadata.DipSwitch.TagKey)))
+                        missingFields.Add(Models.Metadata.DipSwitch.TagKey);
+                    break;
+
+                case Configuration configuration:
+                    if (string.IsNullOrEmpty(configuration.GetName()))
+                        missingFields.Add(Models.Metadata.Configuration.NameKey);
+                    if (string.IsNullOrEmpty(configuration.GetStringFieldValue(Models.Metadata.Configuration.TagKey)))
+                        missingFields.Add(Models.Metadata.Configuration.TagKey);
+                    break;
+
+                case Port port:
+                    if (string.IsNullOrEmpty(port.GetStringFieldValue(Models.Metadata.Port.TagKey)))
+                        missingFields.Add(Models.Metadata.Port.TagKey);
+                    break;
+
+                case Adjuster adjuster:
+                    if (string.IsNullOrEmpty(adjuster.GetName()))
+                        missingFields.Add(Models.Metadata.Adjuster.NameKey);
+                    break;
+
+                case Driver driver:
+                    if (driver.GetStringFieldValue(Models.Metadata.Driver.StatusKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
+                        missingFields.Add(Models.Metadata.Driver.StatusKey);
+                    if (driver.GetStringFieldValue(Models.Metadata.Driver.EmulationKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
+                        missingFields.Add(Models.Metadata.Driver.EmulationKey);
+                    if (driver.GetStringFieldValue(Models.Metadata.Driver.CocktailKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
+                        missingFields.Add(Models.Metadata.Driver.CocktailKey);
+                    if (driver.GetStringFieldValue(Models.Metadata.Driver.SaveStateKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
+                        missingFields.Add(Models.Metadata.Driver.SaveStateKey);
+                    break;
+
+                case Feature feature:
+                    if (feature.GetStringFieldValue(Models.Metadata.Feature.FeatureTypeKey).AsEnumValue<FeatureType>() == FeatureType.NULL)
+                        missingFields.Add(Models.Metadata.Feature.FeatureTypeKey);
+                    break;
+
+                case Device device:
+                    if (device.GetStringFieldValue(Models.Metadata.Device.DeviceTypeKey).AsEnumValue<DeviceType>() != DeviceType.NULL)
+                        missingFields.Add(Models.Metadata.Device.DeviceTypeKey);
+                    break;
+
+                case Slot slot:
+                    if (string.IsNullOrEmpty(slot.GetName()))
+                        missingFields.Add(Models.Metadata.Slot.NameKey);
+                    break;
+
+                case DatItems.Formats.SoftwareList softwarelist:
+                    if (string.IsNullOrEmpty(softwarelist.GetStringFieldValue(Models.Metadata.SoftwareList.TagKey)))
+                        missingFields.Add(Models.Metadata.SoftwareList.TagKey);
+                    if (string.IsNullOrEmpty(softwarelist.GetName()))
+                        missingFields.Add(Models.Metadata.SoftwareList.NameKey);
+                    if (softwarelist.GetStringFieldValue(Models.Metadata.SoftwareList.StatusKey).AsEnumValue<SoftwareListStatus>() == SoftwareListStatus.None)
+                        missingFields.Add(Models.Metadata.SoftwareList.StatusKey);
+                    break;
+
+                case RamOption ramoption:
+                    if (string.IsNullOrEmpty(ramoption.GetName()))
+                        missingFields.Add(Models.Metadata.RamOption.NameKey);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 }

SabreTools.DatFiles/Formats/Logiqx.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing a Logiqx-derived DAT
-    /// </summary>
-    internal partial class Logiqx : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var metadataFile = new Serialization.Files.Logiqx().Deserialize(filename);
-                var metadata = new Serialization.CrossModel.Logiqx().Serialize(metadataFile);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/Logiqx.Writer.cs

@@ -1,162 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.Core.Tools;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing and writing of a Logiqx-derived DAT
-    /// </summary>
-    internal partial class Logiqx : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Archive,
-                ItemType.BiosSet,
-                ItemType.Disk,
-                ItemType.Media,
-                ItemType.Release,
-                ItemType.Rom,
-                ItemType.Sample,
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-            switch (datItem)
-            {
-                case Release release:
-                    if (string.IsNullOrEmpty(release.GetName()))
-                        missingFields.Add(Models.Metadata.Release.NameKey);
-                    if (string.IsNullOrEmpty(release.GetStringFieldValue(Models.Metadata.Release.RegionKey)))
-                        missingFields.Add(Models.Metadata.Release.RegionKey);
-                    break;
-
-                case BiosSet biosset:
-                    if (string.IsNullOrEmpty(biosset.GetName()))
-                        missingFields.Add(Models.Metadata.BiosSet.NameKey);
-                    if (string.IsNullOrEmpty(biosset.GetStringFieldValue(Models.Metadata.BiosSet.DescriptionKey)))
-                        missingFields.Add(Models.Metadata.BiosSet.DescriptionKey);
-                    break;
-
-                case Rom rom:
-                    if (string.IsNullOrEmpty(rom.GetName()))
-                        missingFields.Add(Models.Metadata.Rom.NameKey);
-                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
-                        missingFields.Add(Models.Metadata.Rom.SizeKey);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SpamSumKey)))
-                    {
-                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                    }
-                    break;
-
-                case Disk disk:
-                    if (string.IsNullOrEmpty(disk.GetName()))
-                        missingFields.Add(Models.Metadata.Disk.NameKey);
-                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key))
-                        && string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
-                    {
-                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
-                    }
-                    break;
-
-                case Media media:
-                    if (string.IsNullOrEmpty(media.GetName()))
-                        missingFields.Add(Models.Metadata.Media.NameKey);
-                    if (string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.MD5Key))
-                        && string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SHA1Key))
-                        && string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SHA256Key))
-                        && string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SpamSumKey)))
-                    {
-                        missingFields.Add(Models.Metadata.Media.SHA1Key);
-                    }
-                    break;
-
-                case DeviceRef deviceref:
-                    if (string.IsNullOrEmpty(deviceref.GetName()))
-                        missingFields.Add(Models.Metadata.DeviceRef.NameKey);
-                    break;
-
-                case Sample sample:
-                    if (string.IsNullOrEmpty(sample.GetName()))
-                        missingFields.Add(Models.Metadata.Sample.NameKey);
-                    break;
-
-                case Archive archive:
-                    if (string.IsNullOrEmpty(archive.GetName()))
-                        missingFields.Add(Models.Metadata.Archive.NameKey);
-                    break;
-
-                case Driver driver:
-                    if (driver.GetStringFieldValue(Models.Metadata.Driver.StatusKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
-                        missingFields.Add(Models.Metadata.Driver.StatusKey);
-                    if (driver.GetStringFieldValue(Models.Metadata.Driver.EmulationKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
-                        missingFields.Add(Models.Metadata.Driver.EmulationKey);
-                    if (driver.GetStringFieldValue(Models.Metadata.Driver.CocktailKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
-                        missingFields.Add(Models.Metadata.Driver.CocktailKey);
-                    if (driver.GetStringFieldValue(Models.Metadata.Driver.SaveStateKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
-                        missingFields.Add(Models.Metadata.Driver.SaveStateKey);
-                    break;
-
-                case DatItems.Formats.SoftwareList softwarelist:
-                    if (string.IsNullOrEmpty(softwarelist.GetStringFieldValue(Models.Metadata.SoftwareList.TagKey)))
-                        missingFields.Add(Models.Metadata.SoftwareList.TagKey);
-                    if (string.IsNullOrEmpty(softwarelist.GetName()))
-                        missingFields.Add(Models.Metadata.SoftwareList.NameKey);
-                    if (softwarelist.GetStringFieldValue(Models.Metadata.SoftwareList.StatusKey).AsEnumValue<SoftwareListStatus>() == SoftwareListStatus.None)
-                        missingFields.Add(Models.Metadata.SoftwareList.StatusKey);
-                    break;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var datafile = new Serialization.CrossModel.Logiqx().Deserialize(metadata);
-
-                // Only write the doctype if we don't have No-Intro data
-                bool success;
-                if (string.IsNullOrEmpty(Header.GetStringFieldValue(Models.Metadata.Header.IdKey)))
-                    success = new Serialization.Files.Logiqx().SerializeToFileWithDocType(datafile!, outfile);
-                else
-                    success = new Serialization.Files.Logiqx().Serialize(datafile, outfile);
-
-                if (!success)
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/Logiqx.cs

@@ -1,9 +1,16 @@
-namespace SabreTools.DatFiles.Formats
+using System;
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.Core.Tools;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents a Logiqx-derived DAT
     /// </summary>
-    internal partial class Logiqx : DatFile
+    internal sealed class Logiqx : SerializableDatFile<Models.Logiqx.Datafile, Serialization.Files.Logiqx, Serialization.CrossModel.Logiqx>
     {
         // Private instance variables specific to Logiqx DATs
         private readonly bool _deprecated;
@@ -224,5 +231,152 @@
         {
             _deprecated = deprecated;
         }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Archive,
+                ItemType.BiosSet,
+                ItemType.Disk,
+                ItemType.Media,
+                ItemType.Release,
+                ItemType.Rom,
+                ItemType.Sample,
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+            switch (datItem)
+            {
+                case Release release:
+                    if (string.IsNullOrEmpty(release.GetName()))
+                        missingFields.Add(Models.Metadata.Release.NameKey);
+                    if (string.IsNullOrEmpty(release.GetStringFieldValue(Models.Metadata.Release.RegionKey)))
+                        missingFields.Add(Models.Metadata.Release.RegionKey);
+                    break;
+
+                case BiosSet biosset:
+                    if (string.IsNullOrEmpty(biosset.GetName()))
+                        missingFields.Add(Models.Metadata.BiosSet.NameKey);
+                    if (string.IsNullOrEmpty(biosset.GetStringFieldValue(Models.Metadata.BiosSet.DescriptionKey)))
+                        missingFields.Add(Models.Metadata.BiosSet.DescriptionKey);
+                    break;
+
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetName()))
+                        missingFields.Add(Models.Metadata.Rom.NameKey);
+                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
+                        missingFields.Add(Models.Metadata.Rom.SizeKey);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SpamSumKey)))
+                    {
+                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
+                    }
+                    break;
+
+                case Disk disk:
+                    if (string.IsNullOrEmpty(disk.GetName()))
+                        missingFields.Add(Models.Metadata.Disk.NameKey);
+                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key))
+                        && string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
+                    {
+                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
+                    }
+                    break;
+
+                case Media media:
+                    if (string.IsNullOrEmpty(media.GetName()))
+                        missingFields.Add(Models.Metadata.Media.NameKey);
+                    if (string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.MD5Key))
+                        && string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SHA1Key))
+                        && string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SHA256Key))
+                        && string.IsNullOrEmpty(media.GetStringFieldValue(Models.Metadata.Media.SpamSumKey)))
+                    {
+                        missingFields.Add(Models.Metadata.Media.SHA1Key);
+                    }
+                    break;
+
+                case DeviceRef deviceref:
+                    if (string.IsNullOrEmpty(deviceref.GetName()))
+                        missingFields.Add(Models.Metadata.DeviceRef.NameKey);
+                    break;
+
+                case Sample sample:
+                    if (string.IsNullOrEmpty(sample.GetName()))
+                        missingFields.Add(Models.Metadata.Sample.NameKey);
+                    break;
+
+                case Archive archive:
+                    if (string.IsNullOrEmpty(archive.GetName()))
+                        missingFields.Add(Models.Metadata.Archive.NameKey);
+                    break;
+
+                case Driver driver:
+                    if (driver.GetStringFieldValue(Models.Metadata.Driver.StatusKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
+                        missingFields.Add(Models.Metadata.Driver.StatusKey);
+                    if (driver.GetStringFieldValue(Models.Metadata.Driver.EmulationKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
+                        missingFields.Add(Models.Metadata.Driver.EmulationKey);
+                    if (driver.GetStringFieldValue(Models.Metadata.Driver.CocktailKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
+                        missingFields.Add(Models.Metadata.Driver.CocktailKey);
+                    if (driver.GetStringFieldValue(Models.Metadata.Driver.SaveStateKey).AsEnumValue<SupportStatus>() == SupportStatus.NULL)
+                        missingFields.Add(Models.Metadata.Driver.SaveStateKey);
+                    break;
+
+                case DatItems.Formats.SoftwareList softwarelist:
+                    if (string.IsNullOrEmpty(softwarelist.GetStringFieldValue(Models.Metadata.SoftwareList.TagKey)))
+                        missingFields.Add(Models.Metadata.SoftwareList.TagKey);
+                    if (string.IsNullOrEmpty(softwarelist.GetName()))
+                        missingFields.Add(Models.Metadata.SoftwareList.NameKey);
+                    if (softwarelist.GetStringFieldValue(Models.Metadata.SoftwareList.StatusKey).AsEnumValue<SoftwareListStatus>() == SoftwareListStatus.None)
+                        missingFields.Add(Models.Metadata.SoftwareList.StatusKey);
+                    break;
+            }
+
+            return missingFields;
+        }
+
+        /// <inheritdoc/>
+        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
+        {
+            try
+            {
+                logger.User($"Writing to '{outfile}'...");
+
+                // Serialize the input file
+                var metadata = ConvertMetadata(ignoreblanks);
+                var datafile = new Serialization.CrossModel.Logiqx().Deserialize(metadata);
+
+                // Only write the doctype if we don't have No-Intro data
+                bool success;
+                if (string.IsNullOrEmpty(Header.GetStringFieldValue(Models.Metadata.Header.IdKey)))
+                    success = new Serialization.Files.Logiqx().SerializeToFileWithDocType(datafile!, outfile);
+                else
+                    success = new Serialization.Files.Logiqx().Serialize(datafile, outfile);
+
+                if (!success)
+                {
+                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
+                    return false;
+                }
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                logger.Error(ex);
+                return false;
+            }
+
+            logger.User($"'{outfile}' written!{Environment.NewLine}");
+            return true;
+        }
     }
 }

SabreTools.DatFiles/Formats/Missfile.Reader.cs

@@ -1,17 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing a Missfile
-    /// </summary>
-    internal partial class Missfile : DatFile
-    {
-        /// <inheritdoc/>
-        /// <remarks>There is no consistent way to parse a missfile</remarks>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}

SabreTools.DatFiles/Formats/Missfile.Writer.cs

@@ -1,103 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-using SabreTools.Core;
-using SabreTools.DatItems;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents writing a Missfile
-    /// </summary>
-    internal partial class Missfile : DatFile
-    {
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            // TODO: Check required fields
-            return null;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-                FileStream fs = File.Create(outfile);
-
-                // If we get back null for some reason, just log and return
-                if (fs == null)
-                {
-                    logger.Warning($"File '{outfile}' could not be created for writing! Please check to see if the file is writable");
-                    return false;
-                }
-
-                StreamWriter sw = new(fs, new UTF8Encoding(false));
-
-                // Write out each of the machines and roms
-                string? lastgame = null;
-
-                // Use a sorted list of games to output
-                foreach (string key in Items.SortedKeys)
-                {
-                    ConcurrentList<DatItem> datItems = Items.FilteredItems(key);
-
-                    // If this machine doesn't contain any writable items, skip
-                    if (!ContainsWritable(datItems))
-                        continue;
-
-                    // Resolve the names in the block
-                    datItems = DatItem.ResolveNames(datItems);
-
-                    for (int index = 0; index < datItems.Count; index++)
-                    {
-                        DatItem datItem = datItems[index];
-
-                        // Check for a "null" item
-                        datItem = ProcessNullifiedItem(datItem);
-
-                        // Write out the item if we're using machine names or we're not ignoring
-                        if (!Header.GetBoolFieldValue(DatHeader.UseRomNameKey) == true || !ShouldIgnore(datItem, ignoreblanks))
-                            WriteDatItem(sw, datItem, lastgame);
-
-                        // Set the new data to compare against
-                        lastgame = datItem.GetFieldValue<Machine>(DatItem.MachineKey)!.GetStringFieldValue(Models.Metadata.Machine.NameKey);
-                    }
-                }
-
-                logger.User($"'{outfile}' written!{Environment.NewLine}");
-                sw.Dispose();
-                fs.Dispose();
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Write out DatItem using the supplied StreamWriter
-        /// </summary>
-        /// <param name="sw">StreamWriter to output to</param>
-        /// <param name="datItem">DatItem object to be output</param>
-        /// <param name="lastgame">The name of the last game to be output</param>
-        private void WriteDatItem(StreamWriter sw, DatItem datItem, string? lastgame)
-        {
-            // Process the item name
-            ProcessItemName(datItem, false, forceRomName: false);
-
-            // Romba mode automatically uses item name
-            if (Header.GetFieldValue<DepotInformation?>(DatHeader.OutputDepotKey)?.IsActive == true || Header.GetBoolFieldValue(DatHeader.UseRomNameKey) == true)
-                sw.Write($"{datItem.GetName() ?? string.Empty}\n");
-            else if (!Header.GetBoolFieldValue(DatHeader.UseRomNameKey) == true && datItem.GetFieldValue<Machine>(DatItem.MachineKey)!.GetStringFieldValue(Models.Metadata.Machine.NameKey) != lastgame)
-                sw.Write($"{datItem.GetFieldValue<Machine>(DatItem.MachineKey)!.GetStringFieldValue(Models.Metadata.Machine.NameKey) ?? string.Empty}\n");
-
-            sw.Flush();
-        }
-    }
-}

SabreTools.DatFiles/Formats/Missfile.cs

@@ -1,9 +1,16 @@
-namespace SabreTools.DatFiles.Formats
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using SabreTools.Core;
+using SabreTools.DatItems;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents a Missfile
     /// </summary>
-    internal partial class Missfile : DatFile
+    internal sealed class Missfile : DatFile
     {
         /// <summary>
         /// Constructor designed for casting a base DatFile
@@ -13,5 +20,100 @@
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        /// <remarks>There is no consistent way to parse a missfile</remarks>
+        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            // TODO: Check required fields
+            return null;
+        }
+
+        /// <inheritdoc/>
+        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
+        {
+            try
+            {
+                logger.User($"Writing to '{outfile}'...");
+                FileStream fs = File.Create(outfile);
+
+                // If we get back null for some reason, just log and return
+                if (fs == null)
+                {
+                    logger.Warning($"File '{outfile}' could not be created for writing! Please check to see if the file is writable");
+                    return false;
+                }
+
+                StreamWriter sw = new(fs, new UTF8Encoding(false));
+
+                // Write out each of the machines and roms
+                string? lastgame = null;
+
+                // Use a sorted list of games to output
+                foreach (string key in Items.SortedKeys)
+                {
+                    ConcurrentList<DatItem> datItems = Items.FilteredItems(key);
+
+                    // If this machine doesn't contain any writable items, skip
+                    if (!ContainsWritable(datItems))
+                        continue;
+
+                    // Resolve the names in the block
+                    datItems = DatItem.ResolveNames(datItems);
+
+                    for (int index = 0; index < datItems.Count; index++)
+                    {
+                        DatItem datItem = datItems[index];
+
+                        // Check for a "null" item
+                        datItem = ProcessNullifiedItem(datItem);
+
+                        // Write out the item if we're using machine names or we're not ignoring
+                        if (!Header.GetBoolFieldValue(DatHeader.UseRomNameKey) == true || !ShouldIgnore(datItem, ignoreblanks))
+                            WriteDatItem(sw, datItem, lastgame);
+
+                        // Set the new data to compare against
+                        lastgame = datItem.GetFieldValue<Machine>(DatItem.MachineKey)!.GetStringFieldValue(Models.Metadata.Machine.NameKey);
+                    }
+                }
+
+                logger.User($"'{outfile}' written!{Environment.NewLine}");
+                sw.Dispose();
+                fs.Dispose();
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                logger.Error(ex);
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Write out DatItem using the supplied StreamWriter
+        /// </summary>
+        /// <param name="sw">StreamWriter to output to</param>
+        /// <param name="datItem">DatItem object to be output</param>
+        /// <param name="lastgame">The name of the last game to be output</param>
+        private void WriteDatItem(StreamWriter sw, DatItem datItem, string? lastgame)
+        {
+            // Process the item name
+            ProcessItemName(datItem, false, forceRomName: false);
+
+            // Romba mode automatically uses item name
+            if (Header.GetFieldValue<DepotInformation?>(DatHeader.OutputDepotKey)?.IsActive == true || Header.GetBoolFieldValue(DatHeader.UseRomNameKey) == true)
+                sw.Write($"{datItem.GetName() ?? string.Empty}\n");
+            else if (!Header.GetBoolFieldValue(DatHeader.UseRomNameKey) == true && datItem.GetFieldValue<Machine>(DatItem.MachineKey)!.GetStringFieldValue(Models.Metadata.Machine.NameKey) != lastgame)
+                sw.Write($"{datItem.GetFieldValue<Machine>(DatItem.MachineKey)!.GetStringFieldValue(Models.Metadata.Machine.NameKey) ?? string.Empty}\n");
+
+            sw.Flush();
+        }
     }
 }

SabreTools.DatFiles/Formats/OfflineList.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing an OfflineList XML DAT
-    /// </summary>
-    internal partial class OfflineList : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var dat = new Serialization.Files.OfflineList().Deserialize(filename);
-                var metadata = new Serialization.CrossModel.OfflineList().Serialize(dat);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/OfflineList.Writer.cs

@@ -1,67 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents writing an OfflineList XML DAT
-    /// </summary>
-    internal partial class OfflineList : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Rom
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-
-            switch (datItem)
-            {
-                case Rom rom:
-                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
-                        missingFields.Add(Models.Metadata.Rom.SizeKey);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
-                        missingFields.Add(Models.Metadata.Rom.CRCKey);
-                    break;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var datafile = new Serialization.CrossModel.OfflineList().Deserialize(metadata);
-                if (!(new Serialization.Files.OfflineList().Serialize(datafile, outfile)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/OfflineList.cs

@@ -1,9 +1,14 @@
-namespace SabreTools.DatFiles.Formats
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents an OfflineList XML DAT
     /// </summary>
-    internal partial class OfflineList : DatFile
+    internal sealed class OfflineList : SerializableDatFile<Models.OfflineList.Dat, Serialization.Files.OfflineList, Serialization.CrossModel.OfflineList>
     {
         /// <summary>
         /// Constructor designed for casting a base DatFile
@@ -13,5 +18,32 @@
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Rom
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+
+            switch (datItem)
+            {
+                case Rom rom:
+                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
+                        missingFields.Add(Models.Metadata.Rom.SizeKey);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
+                        missingFields.Add(Models.Metadata.Rom.CRCKey);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 }

SabreTools.DatFiles/Formats/OpenMSX.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing an openMSX softawre list XML DAT
-    /// </summary>
-    internal partial class OpenMSX : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var softwareDb = new Serialization.Files.OpenMSX().Deserialize(filename);
-                var metadata = new Serialization.CrossModel.OpenMSX().Serialize(softwareDb);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/OpenMSX.Writer.cs

@@ -1,189 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using SabreTools.Core;
-using SabreTools.Core.Tools;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents writing an openMSX softawre list XML DAT
-    /// </summary>
-    internal partial class OpenMSX : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Rom
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-
-            // Check item name
-            if (string.IsNullOrEmpty(datItem.GetName()))
-                missingFields.Add(Models.Metadata.Rom.NameKey);
-
-            switch (datItem)
-            {
-                case Rom rom:
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
-                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                    break;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // TODO: Write out comment prefix somehow
-                //var softwaredb = CreateSoftwareDb(ignoreblanks);
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var softwaredb = new Serialization.CrossModel.OpenMSX().Deserialize(metadata);
-                if (!(new Serialization.Files.OpenMSX().SerializeToFileWithDocType(softwaredb!, outfile)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-
-        #region Converters
-
-        /// <summary>
-        /// Create a SoftwareDb from the current internal information
-        /// <summary>
-        /// <param name="ignoreblanks">True if blank roms should be skipped on output, false otherwise</param>
-        private Models.OpenMSX.SoftwareDb CreateSoftwareDb(bool ignoreblanks)
-        {
-            var softwaredb = new Models.OpenMSX.SoftwareDb
-            {
-                Timestamp = Header.GetStringFieldValue(Models.Metadata.Header.DateKey),
-                Software = CreateSoftwares(ignoreblanks)
-            };
-            return softwaredb;
-        }
-
-        /// <summary>
-        /// Create an array of Software from the current internal information
-        /// <summary>
-        /// <param name="ignoreblanks">True if blank roms should be skipped on output, false otherwise</param>
-        private Models.OpenMSX.Software[]? CreateSoftwares(bool ignoreblanks)
-        {
-            // If we don't have items, we can't do anything
-            if (this.Items == null || !this.Items.Any())
-                return null;
-
-            // Create a list of hold the games
-            var softwares = new List<Models.OpenMSX.Software>();
-
-            // Loop through the sorted items and create games for them
-            foreach (string key in Items.SortedKeys)
-            {
-                var items = Items.FilteredItems(key);
-                if (items == null || !items.Any())
-                    continue;
-
-                // Get the first item for game information
-                var machine = items[0].GetFieldValue<Machine>(DatItem.MachineKey);
-                var software = new Models.OpenMSX.Software
-                {
-                    Title = machine?.GetStringFieldValue(Models.Metadata.Machine.NameKey),
-                    GenMSXID = machine?.GetStringFieldValue(Models.Metadata.Machine.GenMSXIDKey),
-                    System = machine?.GetStringFieldValue(Models.Metadata.Machine.SystemKey),
-                    Company = machine?.GetStringFieldValue(Models.Metadata.Machine.ManufacturerKey),
-                    Year = machine?.GetStringFieldValue(Models.Metadata.Machine.YearKey),
-                    Country = machine?.GetStringFieldValue(Models.Metadata.Machine.CountryKey),
-                };
-
-                // Create holder for dumps
-                var dumps = new List<Models.OpenMSX.Dump>();
-
-                // Loop through and convert the items to respective lists
-                for (int index = 0; index < items.Count; index++)
-                {
-                    // Get the item
-                    var item = items[index];
-
-                    // Check for a "null" item
-                    item = ProcessNullifiedItem(item);
-
-                    // Skip if we're ignoring the item
-                    if (ShouldIgnore(item, ignoreblanks))
-                        continue;
-
-                    switch (item)
-                    {
-                        case Rom rom:
-                            dumps.Add(CreateDump(rom));
-                            break;
-                    }
-                }
-
-                software.Dump = [.. dumps];
-                softwares.Add(software);
-            }
-
-            return [.. softwares];
-        }
-
-        /// <summary>
-        /// Create a Dump from the current Rom DatItem
-        /// <summary>
-        private static Models.OpenMSX.Dump CreateDump(Rom item)
-        {
-            Models.OpenMSX.Original? original = null;
-            if (item.OriginalSpecified && item.GetFieldValue<Original?>("ORIGINAL") != null)
-            {
-                original = new Models.OpenMSX.Original { Content = item.GetFieldValue<Original?>("ORIGINAL")!.Content };
-                if (item.GetFieldValue<Original?>("ORIGINAL")!.Value != null)
-                    original.Value = item.GetFieldValue<Original?>("ORIGINAL")!.Value.ToString();
-            }
-
-            Models.OpenMSX.RomBase rom = item.GetStringFieldValue(Models.Metadata.Rom.OpenMSXMediaType).AsEnumValue<OpenMSXSubType>() switch
-            {
-                OpenMSXSubType.MegaRom => new Models.OpenMSX.MegaRom(),
-                OpenMSXSubType.SCCPlusCart => new Models.OpenMSX.SCCPlusCart(),
-                _ => new Models.OpenMSX.Rom(),
-            };
-
-            rom.Start = item.GetStringFieldValue(Models.Metadata.Rom.StartKey);
-            rom.Type = item.GetStringFieldValue(Models.Metadata.Rom.OpenMSXType);
-            rom.Hash = item.GetStringFieldValue(Models.Metadata.Rom.SHA1Key);
-            rom.Remark = item.GetStringFieldValue(Models.Metadata.Rom.RemarkKey);
-
-            var dump = new Models.OpenMSX.Dump
-            {
-                Original = original,
-                Rom = rom,
-            };
-
-            return dump;
-        }
-
-        #endregion
-    }
-}

SabreTools.DatFiles/Formats/OpenMSX.cs

@@ -1,9 +1,14 @@
-namespace SabreTools.DatFiles.Formats
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents an openMSX softawre list XML DAT
     /// </summary>
-    internal partial class OpenMSX : DatFile
+    internal sealed class OpenMSX : SerializableDatFile<Models.OpenMSX.SoftwareDb, Serialization.Files.OpenMSX, Serialization.CrossModel.OpenMSX>
     {
         /// <summary>
         /// DTD for original openMSX DATs
@@ -44,5 +49,34 @@ The softwaredb.xml file contains information about rom mapper types
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Rom
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key)))
+                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 }

SabreTools.DatFiles/Formats/RomCenter.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing a RomCenter INI file
-    /// </summary>
-    internal partial class RomCenter : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var metadataFile = new Serialization.Files.RomCenter().Deserialize(filename);
-                var metadata = new Serialization.CrossModel.RomCenter().Serialize(metadataFile);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/RomCenter.Writer.cs

@@ -1,71 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents writing a RomCenter INI file
-    /// </summary>
-    internal partial class RomCenter : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Rom
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-
-            // Check item name
-            if (string.IsNullOrEmpty(datItem.GetName()))
-                missingFields.Add(Models.Metadata.Rom.NameKey);
-
-            switch (datItem)
-            {
-                case Rom rom:
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
-                        missingFields.Add(Models.Metadata.Rom.CRCKey);
-                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
-                        missingFields.Add(Models.Metadata.Rom.SizeKey);
-                    break;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var metadataFile = new Serialization.CrossModel.RomCenter().Deserialize(metadata);
-                if (!(new Serialization.Files.RomCenter().Serialize(metadataFile, outfile)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/RomCenter.cs

@@ -1,9 +1,14 @@
-namespace SabreTools.DatFiles.Formats
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents a RomCenter INI file
     /// </summary>
-    internal partial class RomCenter : DatFile
+    internal sealed class RomCenter : SerializableDatFile<Models.RomCenter.MetadataFile, Serialization.Files.RomCenter, Serialization.CrossModel.RomCenter>
     {
         /// <summary>
         /// Constructor designed for casting a base DatFile
@@ -13,5 +18,36 @@
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Rom
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Rom rom:
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey)))
+                        missingFields.Add(Models.Metadata.Rom.CRCKey);
+                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
+                        missingFields.Add(Models.Metadata.Rom.SizeKey);
+                    break;
+            }
+
+            return missingFields;
+        }
     }
 }

SabreTools.DatFiles/Formats/SeparatedValue.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing a value-separated DAT
-    /// </summary>
-    internal partial class SeparatedValue : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var metadataFile = new Serialization.Files.SeparatedValue().Deserialize(filename, _delim);
-                var metadata = new Serialization.CrossModel.SeparatedValue().Serialize(metadataFile);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/SeparatedValue.Writer.cs

@@ -1,89 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SabreTools.Core;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents writing a value-separated DAT
-    /// </summary>
-    internal partial class SeparatedValue : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.Disk,
-                ItemType.Media,
-                ItemType.Rom
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-
-            // Check item name
-            if (string.IsNullOrEmpty(datItem.GetName()))
-                missingFields.Add(Models.Metadata.Rom.NameKey);
-
-            switch (datItem)
-            {
-                case Disk disk:
-                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key))
-                        && string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
-                    {
-                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
-                    }
-                    break;
-
-                case Rom rom:
-                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
-                        missingFields.Add(Models.Metadata.Rom.SizeKey);
-                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key))
-                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SpamSumKey)))
-                    {
-                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
-                    }
-                    break;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var metadataFile = new Serialization.CrossModel.SeparatedValue().Deserialize(metadata);
-                if (!(new Serialization.Files.SeparatedValue().Serialize(metadataFile, outfile, _delim)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/SeparatedValue.cs

@@ -1,9 +1,15 @@
-namespace SabreTools.DatFiles.Formats
+using System;
+using System.Collections.Generic;
+using SabreTools.Core;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
+namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents a value-separated DAT
     /// </summary>
-    internal partial class SeparatedValue : DatFile
+    internal sealed class SeparatedValue : SerializableDatFile<Models.SeparatedValue.MetadataFile, Serialization.Files.SeparatedValue, Serialization.CrossModel.SeparatedValue>
     {
         // Private instance variables specific to Separated Value DATs
         private readonly char _delim;
@@ -18,5 +24,99 @@
         {
             _delim = delim;
         }
+
+        /// <inheritdoc/>
+        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
+        {
+            try
+            {
+                // Deserialize the input file
+                var metadataFile = new Serialization.Files.SeparatedValue().Deserialize(filename, _delim);
+                var metadata = new Serialization.CrossModel.SeparatedValue().Serialize(metadataFile);
+
+                // Convert to the internal format
+                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                string message = $"'{filename}' - An error occurred during parsing";
+                logger.Error(ex, message);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.Disk,
+                ItemType.Media,
+                ItemType.Rom
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+
+            // Check item name
+            if (string.IsNullOrEmpty(datItem.GetName()))
+                missingFields.Add(Models.Metadata.Rom.NameKey);
+
+            switch (datItem)
+            {
+                case Disk disk:
+                    if (string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.MD5Key))
+                        && string.IsNullOrEmpty(disk.GetStringFieldValue(Models.Metadata.Disk.SHA1Key)))
+                    {
+                        missingFields.Add(Models.Metadata.Disk.SHA1Key);
+                    }
+                    break;
+
+                case Rom rom:
+                    if (rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) == null || rom.GetInt64FieldValue(Models.Metadata.Rom.SizeKey) < 0)
+                        missingFields.Add(Models.Metadata.Rom.SizeKey);
+                    if (string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.CRCKey))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.MD5Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA1Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA256Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA384Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SHA512Key))
+                        && string.IsNullOrEmpty(rom.GetStringFieldValue(Models.Metadata.Rom.SpamSumKey)))
+                    {
+                        missingFields.Add(Models.Metadata.Rom.SHA1Key);
+                    }
+                    break;
+            }
+
+            return missingFields;
+        }
+
+        /// <inheritdoc/>
+        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
+        {
+            try
+            {
+                logger.User($"Writing to '{outfile}'...");
+
+                // Serialize the input file
+                var metadata = ConvertMetadata(ignoreblanks);
+                var metadataFile = new Serialization.CrossModel.SeparatedValue().Deserialize(metadata);
+                if (!(new Serialization.Files.SeparatedValue().Serialize(metadataFile, outfile, _delim)))
+                {
+                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
+                    return false;
+                }
+            }
+            catch (Exception ex) when (!throwOnError)
+            {
+                logger.Error(ex);
+                return false;
+            }
+
+            logger.User($"'{outfile}' written!{Environment.NewLine}");
+            return true;
+        }
     }
 }

SabreTools.DatFiles/Formats/SoftwareList.Reader.cs

@@ -1,29 +0,0 @@
-using System;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents parsing a SoftwareList
-    /// </summary>
-    internal partial class SoftwareList : DatFile
-    {
-        /// <inheritdoc/>
-        public override void ParseFile(string filename, int indexId, bool keep, bool statsOnly = false, bool throwOnError = false)
-        {
-            try
-            {
-                // Deserialize the input file
-                var softwarelist = new Serialization.Files.SoftwareList().Deserialize(filename);
-                var metadata = new Serialization.CrossModel.SoftwareList().Serialize(softwarelist);
-
-                // Convert to the internal format
-                ConvertMetadata(metadata, filename, indexId, keep, statsOnly);
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                string message = $"'{filename}' - An error occurred during parsing";
-                logger.Error(ex, message);
-            }
-        }
-    }
-}

SabreTools.DatFiles/Formats/SoftwareList.Writer.cs

@@ -1,161 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using SabreTools.Core;
-using SabreTools.DatItems;
-using SabreTools.DatItems.Formats;
-
-namespace SabreTools.DatFiles.Formats
-{
-    /// <summary>
-    /// Represents writing a SoftwareList
-    /// </summary>
-    internal partial class SoftwareList : DatFile
-    {
-        /// <inheritdoc/>
-        protected override ItemType[] GetSupportedTypes()
-        {
-            return
-            [
-                ItemType.DipSwitch,
-                ItemType.Disk,
-                ItemType.Info,
-                ItemType.PartFeature,
-                ItemType.Rom,
-                ItemType.SharedFeat,
-            ];
-        }
-
-        /// <inheritdoc/>
-        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
-        {
-            var missingFields = new List<string>();
-
-            switch (datItem)
-            {
-                case DipSwitch dipSwitch:
-                    if (!dipSwitch.PartSpecified)
-                    {
-                        missingFields.Add(Models.Metadata.Part.NameKey);
-                        missingFields.Add(Models.Metadata.Part.InterfaceKey);
-                    }
-                    else
-                    {
-                        if (string.IsNullOrEmpty(dipSwitch.GetFieldValue<Part?>(DipSwitch.PartKey)!.GetName()))
-                            missingFields.Add(Models.Metadata.Part.NameKey);
-                        if (string.IsNullOrEmpty(dipSwitch.GetFieldValue<Part?>(DipSwitch.PartKey)!.GetStringFieldValue(Models.Metadata.Part.InterfaceKey)))
-                            missingFields.Add(Models.Metadata.Part.InterfaceKey);
-                    }
-                    if (string.IsNullOrEmpty(dipSwitch.GetName()))
-                        missingFields.Add(Models.Metadata.DipSwitch.NameKey);
-                    if (string.IsNullOrEmpty(dipSwitch.GetStringFieldValue(Models.Metadata.DipSwitch.TagKey)))
-                        missingFields.Add(Models.Metadata.DipSwitch.TagKey);
-                    if (string.IsNullOrEmpty(dipSwitch.GetStringFieldValue(Models.Metadata.DipSwitch.MaskKey)))
-                        missingFields.Add(Models.Metadata.DipSwitch.MaskKey);
-                    if (dipSwitch.ValuesSpecified)
-                    {
-                        if (dipSwitch.GetFieldValue<DipValue[]?>(Models.Metadata.DipSwitch.DipValueKey)!.Any(dv => string.IsNullOrEmpty(dv.GetName())))
-                            missingFields.Add(Models.Metadata.DipValue.NameKey);
-                        if (dipSwitch.GetFieldValue<DipValue[]?>(Models.Metadata.DipSwitch.DipValueKey)!.Any(dv => string.IsNullOrEmpty(dv.GetStringFieldValue(Models.Metadata.DipValue.ValueKey))))
-                            missingFields.Add(Models.Metadata.DipValue.ValueKey);
-                    }
-
-                    break;
-
-                case Disk disk:
-                    if (!disk.PartSpecified)
-                    {
-                        missingFields.Add(Models.Metadata.Part.NameKey);
-                        missingFields.Add(Models.Metadata.Part.InterfaceKey);
-                    }
-                    else
-                    {
-                        if (string.IsNullOrEmpty(disk.GetFieldValue<Part?>(Disk.PartKey)!.GetName()))
-                            missingFields.Add(Models.Metadata.Part.NameKey);
-                        if (string.IsNullOrEmpty(disk.GetFieldValue<Part?>(Disk.PartKey)!.GetStringFieldValue(Models.Metadata.Part.InterfaceKey)))
-                            missingFields.Add(Models.Metadata.Part.InterfaceKey);
-                    }
-                    if (!disk.DiskAreaSpecified)
-                    {
-                        missingFields.Add(Models.Metadata.DiskArea.NameKey);
-                    }
-                    else
-                    {
-                        if (string.IsNullOrEmpty(disk.GetFieldValue<DiskArea?>(Disk.DiskAreaKey)!.GetName()))
-                            missingFields.Add(Models.Metadata.DiskArea.NameKey);
-                    }
-                    if (string.IsNullOrEmpty(disk.GetName()))
-                        missingFields.Add(Models.Metadata.Disk.NameKey);
-                    break;
-
-                case Info info:
-                    if (string.IsNullOrEmpty(info.GetName()))
-                        missingFields.Add(Models.Metadata.Info.NameKey);
-                    break;
-
-                case Rom rom:
-                    if (!rom.PartSpecified)
-                    {
-                        missingFields.Add(Models.Metadata.Part.NameKey);
-                        missingFields.Add(Models.Metadata.Part.InterfaceKey);
-                    }
-                    else
-                    {
-                        if (string.IsNullOrEmpty(rom.GetFieldValue<Part?>(Rom.PartKey)!.GetName()))
-                            missingFields.Add(Models.Metadata.Part.NameKey);
-                        if (string.IsNullOrEmpty(rom.GetFieldValue<Part?>(Rom.PartKey)!.GetStringFieldValue(Models.Metadata.Part.InterfaceKey)))
-                            missingFields.Add(Models.Metadata.Part.InterfaceKey);
-                    }
-                    if (!rom.DataAreaSpecified)
-                    {
-                        missingFields.Add(Models.Metadata.DataArea.NameKey);
-                        missingFields.Add(Models.Metadata.DataArea.SizeKey);
-                    }
-                    else
-                    {
-                        if (string.IsNullOrEmpty(rom.GetFieldValue<DataArea?>(Rom.DataAreaKey)!.GetName()))
-                            missingFields.Add(Models.Metadata.DataArea.NameKey);
-                        if (rom.GetFieldValue<DataArea?>(Rom.DataAreaKey)!.GetInt64FieldValue(Models.Metadata.DataArea.SizeKey) == null)
-                            missingFields.Add(Models.Metadata.DataArea.SizeKey);
-                    }
-                    break;
-
-                case SharedFeat sharedFeat:
-                    if (string.IsNullOrEmpty(sharedFeat.GetName()))
-                        missingFields.Add(Models.Metadata.SharedFeat.NameKey);
-                    break;
-                default:
-                    // Unsupported ItemTypes should be caught already
-                    return null;
-            }
-
-            return missingFields;
-        }
-
-        /// <inheritdoc/>
-        public override bool WriteToFile(string outfile, bool ignoreblanks = false, bool throwOnError = false)
-        {
-            try
-            {
-                logger.User($"Writing to '{outfile}'...");
-
-                // Serialize the input file
-                var metadata = ConvertMetadata(ignoreblanks);
-                var softwarelist = new Serialization.CrossModel.SoftwareList().Deserialize(metadata);
-                if (!(new Serialization.Files.SoftwareList().SerializeToFileWithDocType(softwarelist!, outfile)))
-                {
-                    logger.Warning($"File '{outfile}' could not be written! See the log for more details.");
-                    return false;
-                }
-            }
-            catch (Exception ex) when (!throwOnError)
-            {
-                logger.Error(ex);
-                return false;
-            }
-
-            logger.User($"'{outfile}' written!{Environment.NewLine}");
-            return true;
-        }
-    }
-}

SabreTools.DatFiles/Formats/SoftwareList.cs

@@ -1,13 +1,15 @@
-// TODO: Use softwarelist.dtd and *try* to make this write more correctly
+using System.Collections.Generic;
+using System.Linq;
+using SabreTools.Core;
+using SabreTools.DatItems;
+using SabreTools.DatItems.Formats;
+
 namespace SabreTools.DatFiles.Formats
 {
     /// <summary>
     /// Represents parsing and writing of a SoftwareList
     /// </summary>
-    /// <remarks>
+    internal sealed class SoftwareList : SerializableDatFile<Models.SoftwareList.SoftwareList, Serialization.Files.SoftwareList, Serialization.CrossModel.SoftwareList>
-    /// TODO: Check and enforce required fields in output
-    /// </remarks>
-    internal partial class SoftwareList : DatFile
     {
         /// <summary>
         /// DTD for original MAME Software List DATs
@@ -78,5 +80,125 @@ namespace SabreTools.DatFiles.Formats
             : base(datFile)
         {
         }
+
+        /// <inheritdoc/>
+        protected override ItemType[] GetSupportedTypes()
+        {
+            return
+            [
+                ItemType.DipSwitch,
+                ItemType.Disk,
+                ItemType.Info,
+                ItemType.PartFeature,
+                ItemType.Rom,
+                ItemType.SharedFeat,
+            ];
+        }
+
+        /// <inheritdoc/>
+        protected override List<string>? GetMissingRequiredFields(DatItem datItem)
+        {
+            var missingFields = new List<string>();
+
+            switch (datItem)
+            {
+                case DipSwitch dipSwitch:
+                    if (!dipSwitch.PartSpecified)
+                    {
+                        missingFields.Add(Models.Metadata.Part.NameKey);
+                        missingFields.Add(Models.Metadata.Part.InterfaceKey);
+                    }
+                    else
+                    {
+                        if (string.IsNullOrEmpty(dipSwitch.GetFieldValue<Part?>(DipSwitch.PartKey)!.GetName()))
+                            missingFields.Add(Models.Metadata.Part.NameKey);
+                        if (string.IsNullOrEmpty(dipSwitch.GetFieldValue<Part?>(DipSwitch.PartKey)!.GetStringFieldValue(Models.Metadata.Part.InterfaceKey)))
+                            missingFields.Add(Models.Metadata.Part.InterfaceKey);
+                    }
+                    if (string.IsNullOrEmpty(dipSwitch.GetName()))
+                        missingFields.Add(Models.Metadata.DipSwitch.NameKey);
+                    if (string.IsNullOrEmpty(dipSwitch.GetStringFieldValue(Models.Metadata.DipSwitch.TagKey)))
+                        missingFields.Add(Models.Metadata.DipSwitch.TagKey);
+                    if (string.IsNullOrEmpty(dipSwitch.GetStringFieldValue(Models.Metadata.DipSwitch.MaskKey)))
+                        missingFields.Add(Models.Metadata.DipSwitch.MaskKey);
+                    if (dipSwitch.ValuesSpecified)
+                    {
+                        if (dipSwitch.GetFieldValue<DipValue[]?>(Models.Metadata.DipSwitch.DipValueKey)!.Any(dv => string.IsNullOrEmpty(dv.GetName())))
+                            missingFields.Add(Models.Metadata.DipValue.NameKey);
+                        if (dipSwitch.GetFieldValue<DipValue[]?>(Models.Metadata.DipSwitch.DipValueKey)!.Any(dv => string.IsNullOrEmpty(dv.GetStringFieldValue(Models.Metadata.DipValue.ValueKey))))
+                            missingFields.Add(Models.Metadata.DipValue.ValueKey);
+                    }
+
+                    break;
+
+                case Disk disk:
+                    if (!disk.PartSpecified)
+                    {
+                        missingFields.Add(Models.Metadata.Part.NameKey);
+                        missingFields.Add(Models.Metadata.Part.InterfaceKey);
+                    }
+                    else
+                    {
+                        if (string.IsNullOrEmpty(disk.GetFieldValue<Part?>(Disk.PartKey)!.GetName()))
+                            missingFields.Add(Models.Metadata.Part.NameKey);
+                        if (string.IsNullOrEmpty(disk.GetFieldValue<Part?>(Disk.PartKey)!.GetStringFieldValue(Models.Metadata.Part.InterfaceKey)))
+                            missingFields.Add(Models.Metadata.Part.InterfaceKey);
+                    }
+                    if (!disk.DiskAreaSpecified)
+                    {
+                        missingFields.Add(Models.Metadata.DiskArea.NameKey);
+                    }
+                    else
+                    {
+                        if (string.IsNullOrEmpty(disk.GetFieldValue<DiskArea?>(Disk.DiskAreaKey)!.GetName()))
+                            missingFields.Add(Models.Metadata.DiskArea.NameKey);
+                    }
+                    if (string.IsNullOrEmpty(disk.GetName()))
+                        missingFields.Add(Models.Metadata.Disk.NameKey);
+                    break;
+
+                case Info info:
+                    if (string.IsNullOrEmpty(info.GetName()))
+                        missingFields.Add(Models.Metadata.Info.NameKey);
+                    break;
+
+                case Rom rom:
+                    if (!rom.PartSpecified)
+                    {
+                        missingFields.Add(Models.Metadata.Part.NameKey);
+                        missingFields.Add(Models.Metadata.Part.InterfaceKey);
+                    }
+                    else
+                    {
+                        if (string.IsNullOrEmpty(rom.GetFieldValue<Part?>(Rom.PartKey)!.GetName()))
+                            missingFields.Add(Models.Metadata.Part.NameKey);
+                        if (string.IsNullOrEmpty(rom.GetFieldValue<Part?>(Rom.PartKey)!.GetStringFieldValue(Models.Metadata.Part.InterfaceKey)))
+                            missingFields.Add(Models.Metadata.Part.InterfaceKey);
+                    }
+                    if (!rom.DataAreaSpecified)
+                    {
+                        missingFields.Add(Models.Metadata.DataArea.NameKey);
+                        missingFields.Add(Models.Metadata.DataArea.SizeKey);
+                    }
+                    else
+                    {
+                        if (string.IsNullOrEmpty(rom.GetFieldValue<DataArea?>(Rom.DataAreaKey)!.GetName()))
+                            missingFields.Add(Models.Metadata.DataArea.NameKey);
+                        if (rom.GetFieldValue<DataArea?>(Rom.DataAreaKey)!.GetInt64FieldValue(Models.Metadata.DataArea.SizeKey) == null)
+                            missingFields.Add(Models.Metadata.DataArea.SizeKey);
+                    }
+                    break;
+
+                case SharedFeat sharedFeat:
+                    if (string.IsNullOrEmpty(sharedFeat.GetName()))
+                        missingFields.Add(Models.Metadata.SharedFeat.NameKey);
+                    break;
+                default:
+                    // Unsupported ItemTypes should be caught already
+                    return null;
+            }
+
+            return missingFields;
+        }
     }
 }