Add some XML serialization attributes

SabreTools.Library/DatFiles/DatFile.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Net;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using System.Xml.Serialization;
 
 using SabreTools.Library.Data;
 using SabreTools.Library.DatItems;
@@ -24,6 +25,7 @@ namespace SabreTools.Library.DatFiles
     /// Represents a format-agnostic DAT
     /// </summary>
     [JsonObject("datfile")]
+    [XmlRoot("datfile")]
     public abstract class DatFile
     {
         #region Fields
@@ -32,12 +34,14 @@ namespace SabreTools.Library.DatFiles
         /// Header values
         /// </summary>
         [JsonProperty("header")]
+        [XmlElement("header")]
         public DatHeader Header { get; set; } = new DatHeader();
 
         /// <summary>
         /// DatItems and related statistics
         /// </summary>
         [JsonProperty("items")]
+        [XmlElement("items")]
         public ItemDictionary Items { get; set; } = new ItemDictionary();
 
         #endregion

SabreTools.Library/DatFiles/DatHeader.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Xml.Serialization;
 
 using SabreTools.Library.DatItems;
 using SabreTools.Library.IO;
@@ -14,6 +15,7 @@ namespace SabreTools.Library.DatFiles
     /// Represents all possible DAT header information
     /// </summary>
     [JsonObject("header")]
+    [XmlRoot("header")]
     public class DatHeader : ICloneable
     {
         #region Fields
@@ -24,108 +26,126 @@ namespace SabreTools.Library.DatFiles
         /// External name of the DAT
         /// </summary>
         [JsonProperty("filename", DefaultValueHandling = DefaultValueHandling.Include)]
+        [XmlElement("filename")]
         public string FileName { get; set; }
 
         /// <summary>
         /// Internal name of the DAT
         /// </summary>
         [JsonProperty("name", DefaultValueHandling = DefaultValueHandling.Include)]
+        [XmlElement("name")]
         public string Name { get; set; }
 
         /// <summary>
         /// DAT description
         /// </summary>
         [JsonProperty("description", DefaultValueHandling = DefaultValueHandling.Include)]
+        [XmlElement("description")]
         public string Description { get; set; }
 
         /// <summary>
         /// Root directory for the files; currently TruRip/EmuARC-exclusive
         /// </summary>
         [JsonProperty("rootdir", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("rootdir")]
         public string RootDir { get; set; }
 
         /// <summary>
         /// General category of items found in the DAT
         /// </summary>
         [JsonProperty("category", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("category")]
         public string Category { get; set; }
 
         /// <summary>
         /// Version of the DAT
         /// </summary>
         [JsonProperty("version", DefaultValueHandling = DefaultValueHandling.Include)]
+        [XmlElement("version")]
         public string Version { get; set; }
 
         /// <summary>
         /// Creation or modification date
         /// </summary>
         [JsonProperty("date", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("date")]
         public string Date { get; set; }
 
         /// <summary>
         /// List of authors who contributed to the DAT
         /// </summary>
         [JsonProperty("author", DefaultValueHandling = DefaultValueHandling.Include)]
+        [XmlElement("author")]
         public string Author { get; set; }
 
         /// <summary>
         /// Email address for DAT author(s)
         /// </summary>
         [JsonProperty("email", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("email")]
         public string Email { get; set; }
 
         /// <summary>
         /// Author or distribution homepage name
         /// </summary>
         [JsonProperty("homepage", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("homepage")]
         public string Homepage { get; set; }
 
         /// <summary>
         /// Author or distribution URL
         /// </summary>
         [JsonProperty("url", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("url")]
         public string Url { get; set; }
 
         /// <summary>
         /// Any comment that does not already fit an existing field
         /// </summary>
         [JsonProperty("comment", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("comment")]
         public string Comment { get; set; }
 
         /// <summary>
         /// Header skipper to be used when loading the DAT
         /// </summary>
         [JsonProperty("header", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("header")]
         public string HeaderSkipper { get; set; }
 
         /// <summary>
         /// Classification of the DAT. Generally only used for SuperDAT
         /// </summary>
         [JsonProperty("type", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("type")]
         public string Type { get; set; }
 
         /// <summary>
         /// Force a merging style when loaded
         /// </summary>
         [JsonProperty("forcemerging", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("forcemerging")]
         public MergingFlag ForceMerging { get; set; }
 
         /// <summary>
         /// Force nodump handling when loaded
         /// </summary>
         [JsonProperty("forcenodump", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("forcenodump")]
         public NodumpFlag ForceNodump { get; set; }
 
         /// <summary>
         /// Force output packing when loaded
         /// </summary>
         [JsonProperty("forcepacking", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("forcepacking")]
         public PackingFlag ForcePacking { get; set; }
 
         /// <summary>
         /// Read or write format
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public DatFormat DatFormat { get; set; }
 
         #endregion
@@ -137,12 +157,14 @@ namespace SabreTools.Library.DatFiles
         /// </summary>
         /// <remarks>Also in Logiqx</remarks>
         [JsonProperty("debug", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("debug")]
         public bool? Debug { get; set; } = null;
 
         /// <summary>
         /// MAME configuration name
         /// </summary>
         [JsonProperty("mameconfig", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("mameconfig")]
         public string MameConfig { get; set; }
 
         #endregion
@@ -153,12 +175,14 @@ namespace SabreTools.Library.DatFiles
         /// Build version
         /// </summary>
         [JsonProperty("build", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("build")]
         public string Build { get; set; }
 
         /// <summary>
         /// Logiqx/RomCenter plugin, OfflineList System
         /// </summary>
         [JsonProperty("system", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("system")]
         public string System { get; set; }
 
         /// <summary>
@@ -166,6 +190,7 @@ namespace SabreTools.Library.DatFiles
         /// </summary>
         /// <remarks>(merged|split|unmerged) "split"</remarks>
         [JsonProperty("rommode", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("rommode")]
         public MergingFlag RomMode { get; set; }
 
         /// <summary>
@@ -173,6 +198,7 @@ namespace SabreTools.Library.DatFiles
         /// </summary>
         /// <remarks>(merged|split|unmerged) "split"</remarks>
         [JsonProperty("biosmode", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("biosmode")]
         public MergingFlag BiosMode { get; set; }
 
         /// <summary>
@@ -180,24 +206,28 @@ namespace SabreTools.Library.DatFiles
         /// </summary>
         /// <remarks>(merged|unmerged) "merged"</remarks>
         [JsonProperty("samplemode", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("samplemode")]
         public MergingFlag SampleMode { get; set; }
 
         /// <summary>
         /// RomCenter lock rom mode
         /// </summary>
         [JsonProperty("lockrommode", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("lockrommode")]
         public bool? LockRomMode { get; set; }
 
         /// <summary>
         /// RomCenter lock bios mode
         /// </summary>
         [JsonProperty("lockbiosmode", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("lockbiosmode")]
         public bool? LockBiosMode { get; set; }
 
         /// <summary>
         /// RomCenter lock sample mode
         /// </summary>
         [JsonProperty("locksamplemode", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("locksamplemode")]
         public bool? LockSampleMode { get; set; }
 
         #endregion
@@ -208,6 +238,7 @@ namespace SabreTools.Library.DatFiles
         /// Output the item name
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public bool UseRomName { get; set; }
 
         #endregion
@@ -218,24 +249,28 @@ namespace SabreTools.Library.DatFiles
         /// Screenshots width
         /// </summary>
         [JsonProperty("screenshotswidth", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("screenshotswidth")]
         public string ScreenshotsWidth { get; set; }
 
         /// <summary>
         /// Screenshots height
         /// </summary>
         [JsonProperty("screenshotsheight", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("screenshotsheight")]
         public string ScreenshotsHeight { get; set; }
 
         /// <summary>
         /// OfflineList info list
         /// </summary>
         [JsonProperty("infos", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("infos")]
         public List<OfflineListInfo> Infos { get; set; }
 
         /// <summary>
         /// OfflineList can-open extensions
         /// </summary>
         [JsonProperty("canopen", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("canopen")]
         public List<string> CanOpen { get; set; }
 
         // TODO: Implement the following header values:
@@ -250,6 +285,7 @@ namespace SabreTools.Library.DatFiles
         /// Rom title
         /// </summary>
         [JsonProperty("romtitle", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("romtitle")]
         public string RomTitle { get; set; }
 
         #endregion
@@ -260,6 +296,7 @@ namespace SabreTools.Library.DatFiles
         /// RomCenter DAT format version
         /// </summary>
         [JsonProperty("rcversion", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("rcversion")]
         public string RomCenterVersion { get; set; }
 
         #endregion
@@ -270,58 +307,123 @@ namespace SabreTools.Library.DatFiles
         /// Text to prepend to all outputted lines
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public string Prefix { get; set; }
 
         /// <summary>
         /// Text to append to all outputted lines
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public string Postfix { get; set; }
 
         /// <summary>
         /// Add a new extension to all items
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public string AddExtension { get; set; }
 
         /// <summary>
         /// Replace all item extensions
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public string ReplaceExtension { get; set; }
 
         /// <summary>
         /// Remove all item extensions
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public bool RemoveExtension { get; set; }
 
         /// <summary>
         /// Output the machine name
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public bool GameName { get; set; }
 
         /// <summary>
         /// Wrap quotes around the entire line, sans prefix and postfix
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public bool Quotes { get; set; }
 
         #endregion
 
+        #region XML Serialization Nullable Specifications
+
+        #region Common
+
+        [JsonIgnore]
+        public bool ForceMergingSpecified { get { return ForceMerging != MergingFlag.None; } }
+
+        [JsonIgnore]
+        public bool ForceNodumpSpecified { get { return ForceNodump != NodumpFlag.None; } }
+
+        [JsonIgnore]
+        public bool ForcePackingSpecified { get { return ForcePacking != PackingFlag.None; } }
+
+        #endregion
+
+        #region ListXML
+
+        [JsonIgnore]
+        public bool DebugSpecified { get { return Debug != null; } }
+
+        #endregion
+
+        #region Logiqx
+
+        [JsonIgnore]
+        public bool RomModeSpecified { get { return RomMode != MergingFlag.None; } }
+        
+        [JsonIgnore]
+        public bool BiosModeSpecified { get { return BiosMode != MergingFlag.None; } }
+        
+        [JsonIgnore]
+        public bool SampleModeSpecified { get { return SampleMode != MergingFlag.None; } }
+
+        [JsonIgnore]
+        public bool LockRomModeSpecified { get { return LockRomMode != null; } }
+
+        [JsonIgnore]
+        public bool LockBiosModeSpecified { get { return LockBiosMode != null; } }
+
+        [JsonIgnore]
+        public bool LockSampleModeSpecified { get { return LockSampleMode != null; } }
+
+        #endregion
+
+        #region OfflineList
+
+        [JsonIgnore]
+        public bool InfosSpecified { get { return Infos != null; } }
+
+        [JsonIgnore]
+        public bool CanOpenSpecified { get { return CanOpen != null; } }
+
+        #endregion
+
+        #endregion // XML Serialization Nullable Specifications
+
         #region Depot Information
 
         /// <summary>
         /// Input depot information
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public DepotInformation InputDepot { get; set; }
 
         /// <summary>
         /// Output depot information
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public DepotInformation OutputDepot { get; set; }
 
         #endregion

SabreTools.Library/DatItems/Auxiliary.cs

@@ -1,13 +1,6 @@
-using System;
+using System.Xml.Serialization;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 
-using SabreTools.Library.DatItems;
-using SabreTools.Library.Filtering;
-using SabreTools.Library.Tools;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
 
 /// <summary>
 /// This holds all of the auxiliary types needed for proper parsing
@@ -22,6 +15,7 @@ namespace SabreTools.Library.DatItems
     /// Represents the OpenMSX original value
     /// </summary>
     [JsonObject("original")]
+    [XmlRoot("original")]
     public class Original
     {
         [JsonProperty("value")]

SabreTools.Library/DatItems/DatItem.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Xml.Serialization;
 
 using SabreTools.Library.Data;
 using SabreTools.Library.FileTypes;
@@ -17,6 +18,44 @@ namespace SabreTools.Library.DatItems
     /// Base class for all items included in a set
     /// </summary>
     [JsonObject("datitem")]
+    [XmlRoot("datitem")]
+    [XmlInclude(typeof(Adjuster))]
+    [XmlInclude(typeof(Analog))]
+    [XmlInclude(typeof(Archive))]
+    [XmlInclude(typeof(BiosSet))]
+    [XmlInclude(typeof(Blank))]
+    [XmlInclude(typeof(Chip))]
+    [XmlInclude(typeof(Condition))]
+    [XmlInclude(typeof(Configuration))]
+    [XmlInclude(typeof(Control))]
+    [XmlInclude(typeof(DataArea))]
+    [XmlInclude(typeof(Device))]
+    [XmlInclude(typeof(DeviceReference))]
+    [XmlInclude(typeof(DipSwitch))]
+    [XmlInclude(typeof(Disk))]
+    [XmlInclude(typeof(DiskArea))]
+    [XmlInclude(typeof(Display))]
+    [XmlInclude(typeof(Driver))]
+    [XmlInclude(typeof(Extension))]
+    [XmlInclude(typeof(Feature))]
+    [XmlInclude(typeof(Info))]
+    [XmlInclude(typeof(Input))]
+    [XmlInclude(typeof(Instance))]
+    [XmlInclude(typeof(Location))]
+    [XmlInclude(typeof(Media))]
+    [XmlInclude(typeof(Part))]
+    [XmlInclude(typeof(PartFeature))]
+    [XmlInclude(typeof(Port))]
+    [XmlInclude(typeof(RamOption))]
+    [XmlInclude(typeof(Release))]
+    [XmlInclude(typeof(Rom))]
+    [XmlInclude(typeof(Sample))]
+    [XmlInclude(typeof(Setting))]
+    [XmlInclude(typeof(SharedFeature))]
+    [XmlInclude(typeof(Slot))]
+    [XmlInclude(typeof(SlotOption))]
+    [XmlInclude(typeof(SoftwareList))]
+    [XmlInclude(typeof(Sound))]
     public abstract class DatItem : IEquatable<DatItem>, IComparable<DatItem>, ICloneable
     {
         #region Fields
@@ -28,12 +67,14 @@ namespace SabreTools.Library.DatItems
         /// </summary>
         [JsonProperty("type")]
         [JsonConverter(typeof(StringEnumConverter))]
+        [XmlAttribute("type")]
         public ItemType ItemType { get; set; }
 
         /// <summary>
         /// Duplicate type when compared to another item
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public DupeType DupeType { get; set; }
 
         #endregion
@@ -44,6 +85,7 @@ namespace SabreTools.Library.DatItems
         /// Machine values
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public Machine Machine { get; set; } = new Machine();
 
         #endregion
@@ -54,12 +96,14 @@ namespace SabreTools.Library.DatItems
         /// Source information
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public Source Source { get; set; } = new Source();
 
         /// <summary>
         /// Flag if item should be removed
         /// </summary>
         [JsonIgnore]
+        [XmlIgnore]
         public bool Remove { get; set; }
 
         #endregion

SabreTools.Library/DatItems/Machine.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Xml.Serialization;
 
 using SabreTools.Library.Filtering;
 using SabreTools.Library.Tools;
@@ -13,6 +14,7 @@ namespace SabreTools.Library.DatItems
     /// Represents the information specific to a set/game/machine
     /// </summary>
     [JsonObject("machine")]
+    [XmlRoot("machine")]
     public class Machine : ICloneable
     {
         #region Fields
@@ -23,6 +25,7 @@ namespace SabreTools.Library.DatItems
         /// Name of the machine
         /// </summary>
         [JsonProperty("name", DefaultValueHandling = DefaultValueHandling.Include)]
+        [XmlAttribute("name")]
         public string Name { get; set; } = null;
 
         /// <summary>
@@ -30,54 +33,63 @@ namespace SabreTools.Library.DatItems
         /// </summary>
         /// <remarks>Known as "Extra" in AttractMode</remarks>
         [JsonProperty("comment", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("comment")]
         public string Comment { get; set; } = null;
 
         /// <summary>
         /// Extended description
         /// </summary>
         [JsonProperty("description", DefaultValueHandling = DefaultValueHandling.Include)]
+        [XmlElement("description")]
         public string Description { get; set; } = null;
 
         /// <summary>
         /// Year(s) of release/manufacture
         /// </summary>
         [JsonProperty("year", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("year")]
         public string Year { get; set; } = null;
 
         /// <summary>
         /// Manufacturer, if available
         /// </summary>
         [JsonProperty("manufacturer", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("manufacturer")]
         public string Manufacturer { get; set; } = null;
 
         /// <summary>
         /// Publisher, if available
         /// </summary>
         [JsonProperty("publisher", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("publisher")]
         public string Publisher { get; set; } = null;
 
         /// <summary>
         /// Category, if available
         /// </summary>
         [JsonProperty("category", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("category")]
         public string Category { get; set; } = null;
 
         /// <summary>
         /// fomof parent
         /// </summary>
         [JsonProperty("romof", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlAttribute("romof")]
         public string RomOf { get; set; } = null;
 
         /// <summary>
         /// cloneof parent
         /// </summary>
         [JsonProperty("cloneof", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlAttribute("cloneof")]
         public string CloneOf { get; set; } = null;
 
         /// <summary>
         /// sampleof parent
         /// </summary>
         [JsonProperty("sampleof", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlAttribute("sampleof")]
         public string SampleOf { get; set; } = null;
 
         /// <summary>
@@ -85,6 +97,7 @@ namespace SabreTools.Library.DatItems
         /// </summary>
         [JsonProperty("type", DefaultValueHandling = DefaultValueHandling.Ignore)]
         [JsonConverter(typeof(StringEnumConverter))]
+        [XmlAttribute("type")]
         public MachineType MachineType { get; set; } = 0x0;
 
         #endregion
@@ -96,42 +109,49 @@ namespace SabreTools.Library.DatItems
         /// </summary>
         /// <remarks>Also in Logiqx EmuArc</remarks>
         [JsonProperty("players", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("players")]
         public string Players { get; set; } = null;
 
         /// <summary>
         /// Screen rotation
         /// </summary>
         [JsonProperty("rotation", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("rotation")]
         public string Rotation { get; set; } = null;
 
         /// <summary>
         /// Control method
         /// </summary>
         [JsonProperty("control", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("control")]
         public string Control { get; set; } = null;
 
         /// <summary>
         /// Support status
         /// </summary>
         [JsonProperty("status", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("status")]
         public string Status { get; set; } = null;
 
         /// <summary>
         /// Display count
         /// </summary>
         [JsonProperty("displaycount", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("displaycount")]
         public string DisplayCount { get; set; } = null;
 
         /// <summary>
         /// Display type
         /// </summary>
         [JsonProperty("displaytype", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("displaytype")]
         public string DisplayType { get; set; } = null;
 
         /// <summary>
         /// Number of input buttons
         /// </summary>
         [JsonProperty("buttons", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("buttons")]
         public string Buttons { get; set; } = null;
 
         #endregion
@@ -143,6 +163,7 @@ namespace SabreTools.Library.DatItems
         /// </summary>
         /// <remarks>Also in Logiqx</remarks>
         [JsonProperty("sourcefile", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlAttribute("sourcefile")]
         public string SourceFile { get; set; } = null;
 
         /// <summary>
@@ -150,6 +171,7 @@ namespace SabreTools.Library.DatItems
         /// </summary>
         /// <remarks>Also in Logiqx</remarks>
         [JsonProperty("runnable", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlAttribute("runnable")]
         public Runnable Runnable { get; set; } = Runnable.NULL;
 
         #endregion
@@ -160,12 +182,14 @@ namespace SabreTools.Library.DatItems
         /// Machine board name
         /// </summary>
         [JsonProperty("board", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlAttribute("board")]
         public string Board { get; set; } = null;
 
         /// <summary>
         /// Rebuild location if different than machine name
         /// </summary>
         [JsonProperty("rebuildto", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlAttribute("rebuildto")]
         public string RebuildTo { get; set; } = null;
 
         #endregion
@@ -177,54 +201,63 @@ namespace SabreTools.Library.DatItems
         /// Title ID
         /// </summary>
         [JsonProperty("titleid", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("titleid")]
         public string TitleID { get; set; } = null;
 
         /// <summary>
         /// Machine developer
         /// </summary>
         [JsonProperty("developer", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("developer")]
         public string Developer { get; set; } = null;
 
         /// <summary>
         /// Game genre
         /// </summary>
         [JsonProperty("genre", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("genre")]
         public string Genre { get; set; } = null;
 
         /// <summary>
         /// Game subgenre
         /// </summary>
         [JsonProperty("subgenre", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("subgenre")]
         public string Subgenre { get; set; } = null;
 
         /// <summary>
         /// Game ratings
         /// </summary>
         [JsonProperty("ratings", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("ratings")]
         public string Ratings { get; set; } = null;
 
         /// <summary>
         /// Game score
         /// </summary>
         [JsonProperty("score", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("score")]
         public string Score { get; set; } = null;
 
         /// <summary>
         /// Is the machine enabled
         /// </summary>
         [JsonProperty("enabled", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("enabled")]
         public string Enabled { get; set; } = null; // bool?
 
         /// <summary>
         /// Does the game have a CRC check
         /// </summary>
         [JsonProperty("hascrc", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("hascrc")]
         public bool? Crc { get; set; } = null;
 
         /// <summary>
         /// Machine relations
         /// </summary>
         [JsonProperty("relatedto", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("relatedto")]
         public string RelatedTo { get; set; } = null;
 
         #endregion
@@ -235,18 +268,21 @@ namespace SabreTools.Library.DatItems
         /// Generation MSX ID
         /// </summary>
         [JsonProperty("genmsxid", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("genmsxid")]
         public string GenMSXID { get; set; } = null;
 
         /// <summary>
         /// MSX System
         /// </summary>
         [JsonProperty("system", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("system")]
         public string System { get; set; } = null;
 
         /// <summary>
         /// Machine country of origin
         /// </summary>
         [JsonProperty("country", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("country")]
         public string Country { get; set; } = null;
 
         #endregion
@@ -257,10 +293,43 @@ namespace SabreTools.Library.DatItems
         /// Support status
         /// </summary>
         [JsonProperty("supported", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("supported")]
         public Supported Supported { get; set; } = Supported.NULL;
 
         #endregion
 
+        #region XML Serialization Nullable Specifications
+
+        #region Common
+
+        [JsonIgnore]
+        public bool MachineTypeSpecified { get { return MachineType != 0x0 && MachineType != MachineType.NULL; } }
+
+        #endregion
+
+        #region ListXML
+
+        [JsonIgnore]
+        public bool RunnableSpecified { get { return Runnable != Runnable.NULL; } }
+
+        #endregion
+
+        #region Logiqx EmuArc Fields
+
+        [JsonIgnore]
+        public bool CrcSpecified { get { return Crc != null; } }
+
+        #endregion
+
+        #region SoftwareList
+
+        [JsonIgnore]
+        public bool SupportedSpecified { get { return Supported != Supported.NULL; } }
+
+        #endregion
+
+        #endregion // XML Serialization Nullable Specifications
+
         #endregion
 
         #region Accessors

SabreTools.Library/DatItems/Rom.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Xml.Serialization;
 
 using SabreTools.Library.Data;
 using SabreTools.Library.FileTypes;
@@ -17,6 +18,7 @@ namespace SabreTools.Library.DatItems
     /// Represents a generic file within a set
     /// </summary>
     [JsonObject("rom")]
+    [XmlRoot("rom")]
     public class Rom : DatItem
     {
         #region Private instance variables
@@ -42,24 +44,28 @@ namespace SabreTools.Library.DatItems
         /// Name of the item
         /// </summary>
         [JsonProperty("name")]
+        [XmlAttribute("name")]
         public string Name { get; set; }
 
         /// <summary>
         /// What BIOS is required for this rom
         /// </summary>
         [JsonProperty("bios", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("bios")]
         public string Bios { get; set; }
 
         /// <summary>
         /// Byte size of the rom
         /// </summary>
         [JsonProperty("size", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("size")]
         public long? Size { get; set; }
 
         /// <summary>
         /// File CRC32 hash
         /// </summary>
         [JsonProperty("crc", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("crc")]
         public string CRC
         {
             get { return _crc.IsNullOrEmpty() ? null : Utilities.ByteArrayToString(_crc); }
@@ -70,6 +76,7 @@ namespace SabreTools.Library.DatItems
         /// File MD5 hash
         /// </summary>
         [JsonProperty("md5", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("md5")]
         public string MD5
         {
             get { return _md5.IsNullOrEmpty() ? null : Utilities.ByteArrayToString(_md5); }
@@ -81,6 +88,7 @@ namespace SabreTools.Library.DatItems
         /// File RIPEMD160 hash
         /// </summary>
         [JsonProperty("ripemd160", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("ripemd160")]
         public string RIPEMD160
         {
             get { return _ripemd160.IsNullOrEmpty() ? null : Utilities.ByteArrayToString(_ripemd160); }
@@ -92,6 +100,7 @@ namespace SabreTools.Library.DatItems
         /// File SHA-1 hash
         /// </summary>
         [JsonProperty("sha1", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("sha1")]
         public string SHA1
         {
             get { return _sha1.IsNullOrEmpty() ? null : Utilities.ByteArrayToString(_sha1); }
@@ -102,6 +111,7 @@ namespace SabreTools.Library.DatItems
         /// File SHA-256 hash
         /// </summary>
         [JsonProperty("sha256", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("sha256")]
         public string SHA256
         {
             get { return _sha256.IsNullOrEmpty() ? null : Utilities.ByteArrayToString(_sha256); }
@@ -112,6 +122,7 @@ namespace SabreTools.Library.DatItems
         /// File SHA-384 hash
         /// </summary>
         [JsonProperty("sha384", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("sha384")]
         public string SHA384
         {
             get { return _sha384.IsNullOrEmpty() ? null : Utilities.ByteArrayToString(_sha384); }
@@ -122,6 +133,7 @@ namespace SabreTools.Library.DatItems
         /// File SHA-512 hash
         /// </summary>
         [JsonProperty("sha512", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("sha512")]
         public string SHA512
         {
             get { return _sha512.IsNullOrEmpty() ? null : Utilities.ByteArrayToString(_sha512); }
@@ -132,6 +144,7 @@ namespace SabreTools.Library.DatItems
         /// File SpamSum fuzzy hash
         /// </summary>
         [JsonProperty("spamsum", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("spamsum")]
         public string SpamSum
         {
             get { return _spamsum.IsNullOrEmpty() ? null : Encoding.UTF8.GetString(_spamsum); }
@@ -142,24 +155,28 @@ namespace SabreTools.Library.DatItems
         /// Rom name to merge from parent
         /// </summary>
         [JsonProperty("merge", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("merge")]
         public string MergeTag { get; set; }
 
         /// <summary>
         /// Rom region
         /// </summary>
         [JsonProperty("region", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("biregionos")]
         public string Region { get; set; }
 
         /// <summary>
         /// Data offset within rom
         /// </summary>
         [JsonProperty("offset", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("offset")]
         public string Offset { get; set; }
 
         /// <summary>
         /// File created date
         /// </summary>
         [JsonProperty("date", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("date")]
         public string Date { get; set; }
 
         /// <summary>
@@ -167,18 +184,21 @@ namespace SabreTools.Library.DatItems
         /// </summary>
         [JsonProperty("status", DefaultValueHandling = DefaultValueHandling.Ignore)]
         [JsonConverter(typeof(StringEnumConverter))]
+        [XmlElement("status")]
         public ItemStatus ItemStatus { get; set; }
 
         /// <summary>
         /// Determine if the rom is optional in the set
         /// </summary>
         [JsonProperty("optional", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("optional")]
         public bool? Optional { get; set; }
 
         /// <summary>
         /// Determine if the CRC32 hash is inverted
         /// </summary>
         [JsonProperty("inverted", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("inverted")]
         public bool? Inverted { get; set; }
 
         #endregion
@@ -189,12 +209,14 @@ namespace SabreTools.Library.DatItems
         /// Alternate name for the item
         /// </summary>
         [JsonProperty("alt_romname", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("alt_romname")]
         public string AltName { get; set; }
 
         /// <summary>
         /// Alternate title for the item
         /// </summary>
         [JsonProperty("alt_title", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("alt_title")]
         public string AltTitle { get; set; }
 
         #endregion
@@ -205,12 +227,14 @@ namespace SabreTools.Library.DatItems
         /// OpenMSX sub item type
         /// </summary>
         [JsonProperty("original", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("original")]
         public Original Original { get; set; }
 
         /// <summary>
         /// OpenMSX sub item type
         /// </summary>
         [JsonProperty("openmsx_subtype", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("openmsx_subtype")]
         [JsonConverter(typeof(StringEnumConverter))]
         public OpenMSXSubType OpenMSXSubType { get; set; }
 
@@ -219,18 +243,21 @@ namespace SabreTools.Library.DatItems
         /// </summary>
         /// <remarks>Not related to the subtype above</remarks>
         [JsonProperty("openmsx_type", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("openmsx_type")]
         public string OpenMSXType { get; set; }
 
         /// <summary>
         /// Item remark (like a comment)
         /// </summary>
         [JsonProperty("remark", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("remark")]
         public string Remark { get; set; }
 
         /// <summary>
         /// Boot state
         /// </summary>
         [JsonProperty("boot", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("boot")]
         public string Boot { get; set; }
 
         #endregion
@@ -241,12 +268,14 @@ namespace SabreTools.Library.DatItems
         /// Data area information
         /// </summary>
         [JsonProperty("dataarea", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("dataarea")]
         public DataArea DataArea { get; set; }
 
         /// <summary>
         /// Loading flag
         /// </summary>
         [JsonProperty("loadflag", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("loadflag")]
         [JsonConverter(typeof(StringEnumConverter))]
         public LoadFlag LoadFlag { get; set; }
 
@@ -254,16 +283,61 @@ namespace SabreTools.Library.DatItems
         /// Original hardware part associated with the item
         /// </summary>
         [JsonProperty("part", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("part")]
         public Part Part { get; set; }
 
         /// <summary>
         /// SoftwareList value associated with the item
         /// </summary>
         [JsonProperty("value", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        [XmlElement("value")]
         public string Value { get; set; }
 
         #endregion
 
+        #region XML Serialization Nullable Specifications
+
+        #region Common
+
+        [JsonIgnore]
+        public bool SizeSpecified { get { return Size != null; } }
+
+        [JsonIgnore]
+        public bool ItemStatusSpecified { get { return ItemStatus != ItemStatus.NULL && ItemStatus != ItemStatus.None; } }
+
+        [JsonIgnore]
+        public bool OptionalSpecified { get { return Optional != null; } }
+
+        [JsonIgnore]
+        public bool InvertedSpecified { get { return Inverted != null; } }
+
+        #endregion
+
+        #region OpenMSX
+
+        [JsonIgnore]
+        public bool OriginalSpecified { get { return Original != null && Original != default; } }
+
+        [JsonIgnore]
+        public bool OpenMSXSubTypeSpecified { get { return OpenMSXSubType != OpenMSXSubType.NULL; } }
+
+        #endregion
+
+        #region SoftwareList
+
+        [JsonIgnore]
+        public bool DataAreaSpecified { get { return DataArea != null && DataArea != default; } }
+
+        [JsonIgnore]
+        public bool LoadFlagSpecified { get { return LoadFlag != LoadFlag.NULL; } }
+
+        [JsonIgnore]
+        public bool PartSpecified { get { return Part != null && Part != default; } }
+
+        #endregion
+
+        #endregion // XML Serialization Nullable Specifications
+
         #endregion // Fields
 
         #region Accessors