SabreTools/SabreTools.Serialization
1
0
Fork 0
mirror of https://github.com/SabreTools/SabreTools.Serialization.git synced 2026-04-05 22:01:33 +00:00
Code Issues 56 Packages Projects Releases 20 Wiki Activity

Use XmlTextWriter for XML DAT writing

Browse Source
This commit is contained in:
Matt Nadareski
2026-03-31 18:08:40 -04:00
parent 0670231606
commit 4d362bb791
26 changed files with 4076 additions and 222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
SabreTools.Metadata.DatFiles/Formats/Logiqx.cs
View File

@@ -1,4 +1,4 @@
using System;
using System;
using System.Collections.Generic;
using SabreTools.Data.Extensions;
using SabreTools.Metadata.DatItems;
@@ -382,13 +382,13 @@ namespace SabreTools.Metadata.DatFiles.Formats
var metadata = ConvertToMetadata(ignoreblanks);
var datafile = new Serialization.CrossModel.Logiqx().Deserialize(metadata, _useGame);
// TODO: Reenable doctype writing
// TODO: Enable No-Intro doctype writing instead of Logiqx
// Only write the doctype if we don't have No-Intro data
bool success;
if (string.IsNullOrEmpty(Header.ReadString(Data.Models.Metadata.Header.IdKey)))
success = new Serialization.Writers.Logiqx().Serialize(datafile, outfile, null, null, null, null);
success = new Serialization.Writers.Logiqx().SerializeFile(datafile, outfile);
else
success = new Serialization.Writers.Logiqx().Serialize(datafile, outfile, null, null, null, null);
success = new Serialization.Writers.Logiqx().SerializeFile(datafile, outfile);
if (!success)
{

2
SabreTools.Serialization.Readers.Test/ArchiveDotOrgTests.cs
View File

@@ -80,7 +80,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.ArchiveDotOrg.Files files = Build();
// Serialize to stream
Stream? actual = serializer.Serialize(files);
Stream? actual = serializer.SerializeStream(files);
Assert.NotNull(actual);
// Serialize back to original model

8
SabreTools.Serialization.Readers.Test/ListxmlTests.cs
View File

@@ -80,7 +80,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.Listxml.Mame mame = Build(game: true);
// Serialize to stream
Stream? actual = serializer.Serialize(mame);
Stream? actual = serializer.SerializeStream(mame);
Assert.NotNull(actual);
// Serialize back to original model
@@ -108,7 +108,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.Listxml.Mame mame = Build(game: false);
// Serialize to stream
Stream? actual = serializer.Serialize(mame);
Stream? actual = serializer.SerializeStream(mame);
Assert.NotNull(actual);
// Serialize back to original model
@@ -240,7 +240,7 @@ namespace SabreTools.Serialization.Readers.Test
Service = "XXXXXX",
Tilt = "XXXXXX",
Players = "XXXXXX",
//ControlAttr = "XXXXXX", // Mututally exclusive with input.Control
ControlAttr = "XXXXXX",
Buttons = "XXXXXX",
Coins = "XXXXXX",
Control = [control],
@@ -668,7 +668,7 @@ namespace SabreTools.Serialization.Readers.Test
Assert.Equal("XXXXXX", input.Service);
Assert.Equal("XXXXXX", input.Tilt);
Assert.Equal("XXXXXX", input.Players);
//Assert.Equal("XXXXXX", input.ControlAttr); // Mututally exclusive with input.Control
Assert.Equal("XXXXXX", input.ControlAttr); // Mututally exclusive with input.Control
Assert.Equal("XXXXXX", input.Buttons);
Assert.Equal("XXXXXX", input.Coins);

4
SabreTools.Serialization.Readers.Test/LogiqxTests.cs
View File

@@ -80,7 +80,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.Logiqx.Datafile df = Build(game: true);
// Serialize to stream
Stream? metadata = serializer.Serialize(df);
Stream? metadata = serializer.SerializeStream(df);
Assert.NotNull(metadata);
// Serialize back to original model
@@ -112,7 +112,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.Logiqx.Datafile df = Build(game: false);
// Serialize to stream
Stream? metadata = serializer.Serialize(df);
Stream? metadata = serializer.SerializeStream(df);
Assert.NotNull(metadata);
// Serialize back to original model

4
SabreTools.Serialization.Readers.Test/M1Tests.cs
View File

@@ -80,7 +80,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.Listxml.M1 m1 = Build(game: true);
// Serialize to generic model
Stream? metadata = serializer.Serialize(m1);
Stream? metadata = serializer.SerializeStream(m1);
Assert.NotNull(metadata);
// Serialize to stream
@@ -106,7 +106,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.Listxml.M1 m1 = Build(game: false);
// Serialize to generic model
Stream? metadata = serializer.Serialize(m1);
Stream? metadata = serializer.SerializeStream(m1);
Assert.NotNull(metadata);
// Serialize to stream

4
SabreTools.Serialization.Readers.Test/MessTests.cs
View File

@@ -80,7 +80,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.Listxml.Mess m1 = Build(game: true);
// Serialize to generic model
Stream? metadata = serializer.Serialize(m1);
Stream? metadata = serializer.SerializeStream(m1);
Assert.NotNull(metadata);
// Serialize to stream
@@ -106,7 +106,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.Listxml.Mess m1 = Build(game: false);
// Serialize to generic model
Stream? metadata = serializer.Serialize(m1);
Stream? metadata = serializer.SerializeStream(m1);
Assert.NotNull(metadata);
// Serialize to stream

2
SabreTools.Serialization.Readers.Test/OfflineListTests.cs
View File

@@ -80,7 +80,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.OfflineList.Dat dat = Build();
// Serialize to stream
Stream? metadata = serializer.Serialize(dat);
Stream? metadata = serializer.SerializeStream(dat);
Assert.NotNull(metadata);
// Serialize back to original model

2
SabreTools.Serialization.Readers.Test/OpenMSXTests.cs
View File

@@ -80,7 +80,7 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.OpenMSX.SoftwareDb sdb = Build();
// Serialize to stream
Stream? metadata = serializer.Serialize(sdb);
Stream? metadata = serializer.SerializeStream(sdb);
Assert.NotNull(metadata);
// Serialize back to original model

9
SabreTools.Serialization.Readers.Test/SoftwareListTests.cs
View File

@@ -80,9 +80,16 @@ namespace SabreTools.Serialization.Readers.Test
Data.Models.SoftwareList.SoftwareList sl = Build();
// Serialize to stream
Stream? actual = serializer.Serialize(sl);
Stream? actual = serializer.SerializeStream(sl);
Assert.NotNull(actual);
if (actual is MemoryStream ms)
{
byte[] bytes = ms.ToArray();
string str = System.Text.Encoding.UTF8.GetString(bytes);
System.Console.WriteLine(str);
}
// Serialize back to original model
Data.Models.SoftwareList.SoftwareList? newSl = deserializer.Deserialize(actual);

2
SabreTools.Serialization.Writers.Test/ArchiveDotOrgTests.cs
View File

@@ -17,7 +17,7 @@ namespace SabreTools.Serialization.Writers.Test
public void SerializeStream_Null_Null()
{
var serializer = new ArchiveDotOrg();
Stream? actual = serializer.Serialize(null);
Stream? actual = serializer.SerializeStream(null);
Assert.Null(actual);
}
}

2
SabreTools.Serialization.Writers.Test/ListxmlTests.cs
View File

@@ -17,7 +17,7 @@ namespace SabreTools.Serialization.Writers.Test
public void SerializeStream_Null_Null()
{
var serializer = new Listxml();
Stream? actual = serializer.Serialize(null);
Stream? actual = serializer.SerializeStream(null);
Assert.Null(actual);
}
}

2
SabreTools.Serialization.Writers.Test/LogiqxTests.cs
View File

@@ -17,7 +17,7 @@ namespace SabreTools.Serialization.Writers.Test
public void SerializeStream_Null_Null()
{
var serializer = new Logiqx();
Stream? actual = serializer.Serialize(null);
Stream? actual = serializer.SerializeStream(null);
Assert.Null(actual);
}
}

2
SabreTools.Serialization.Writers.Test/M1Tests.cs
View File

@@ -17,7 +17,7 @@ namespace SabreTools.Serialization.Writers.Test
public void SerializeStream_Null_Null()
{
var serializer = new M1();
Stream? actual = serializer.Serialize(null);
Stream? actual = serializer.SerializeStream(null);
Assert.Null(actual);
}
}

2
SabreTools.Serialization.Writers.Test/MessTests.cs
View File

@@ -17,7 +17,7 @@ namespace SabreTools.Serialization.Writers.Test
public void SerializeStream_Null_Null()
{
var serializer = new Mess();
Stream? actual = serializer.Serialize(null);
Stream? actual = serializer.SerializeStream(null);
Assert.Null(actual);
}
}

2
SabreTools.Serialization.Writers.Test/OfflineListTests.cs
View File

@@ -17,7 +17,7 @@ namespace SabreTools.Serialization.Writers.Test
public void SerializeStream_Null_Null()
{
var serializer = new OfflineList();
Stream? actual = serializer.Serialize(null);
Stream? actual = serializer.SerializeStream(null);
Assert.Null(actual);
}
}

2
SabreTools.Serialization.Writers.Test/OpenMSXTests.cs
View File

@@ -17,7 +17,7 @@ namespace SabreTools.Serialization.Writers.Test
public void SerializeStream_Null_Null()
{
var serializer = new OpenMSX();
Stream? actual = serializer.Serialize(null);
Stream? actual = serializer.SerializeStream(null);
Assert.Null(actual);
}
}

2
SabreTools.Serialization.Writers.Test/SoftwareListTests.cs
View File

@@ -17,7 +17,7 @@ namespace SabreTools.Serialization.Writers.Test
public void SerializeStream_Null_Null()
{
var serializer = new SoftwareList();
Stream? actual = serializer.Serialize(null);
Stream? actual = serializer.SerializeStream(null);
Assert.Null(actual);
}
}

128
SabreTools.Serialization.Writers/ArchiveDotOrg.cs
View File

@@ -1,9 +1,133 @@
using System.IO;
using System.Text;
using System.Xml;
using SabreTools.Data.Models.ArchiveDotOrg;
using SabreTools.IO.Extensions;
using SabreTools.Text.Extensions;
namespace SabreTools.Serialization.Writers
{
public class ArchiveDotOrg : XmlFile<Files>
public class ArchiveDotOrg : BaseBinaryWriter<Files>
{
// All logic taken care of in the base class
/// <inheritdoc/>
public override Stream? SerializeStream(Files? obj)
{
// If the metadata file is null
if (obj is null)
return null;
// Setup the writer and output
var stream = new MemoryStream();
var writer = new XmlTextWriter(stream, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
// Write the files, if they exist
WriteFiles(obj, writer);
writer.Flush();
// Return the stream
stream.SeekIfPossible(0, SeekOrigin.Begin);
return stream;
}
/// <summary>
/// Write a File to an XmlTextWriter
/// </summary>
/// <param name="obj">File to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteFile(Data.Models.ArchiveDotOrg.File obj, XmlTextWriter writer)
{
writer.WriteStartElement("file");
writer.WriteOptionalAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("source", obj.Source);
writer.WriteOptionalElementString("btih", obj.BitTorrentMagnetHash);
writer.WriteOptionalElementString("mtime", obj.LastModifiedTime);
writer.WriteOptionalElementString("size", obj.Size);
writer.WriteOptionalElementString("md5", obj.MD5);
writer.WriteOptionalElementString("crc32", obj.CRC32);
writer.WriteOptionalElementString("sha1", obj.SHA1);
writer.WriteOptionalElementString("filecount", obj.FileCount);
writer.WriteOptionalElementString("format", obj.Format);
writer.WriteOptionalElementString("original", obj.Original);
writer.WriteOptionalElementString("summation", obj.Summation);
writer.WriteOptionalElementString("matrix_number", obj.MatrixNumber);
writer.WriteOptionalElementString("collection-catalog-number", obj.CollectionCatalogNumber);
writer.WriteOptionalElementString("publisher", obj.Publisher);
writer.WriteOptionalElementString("comment", obj.Comment);
// ASR-Related
writer.WriteOptionalElementString("asr_detected_lang", obj.ASRDetectedLang);
writer.WriteOptionalElementString("asr_detected_lang_conf", obj.ASRDetectedLangConf);
writer.WriteOptionalElementString("asr_transcribed_lang", obj.ASRTranscribedLang);
writer.WriteOptionalElementString("whisper_asr_module_version", obj.WhisperASRModuleVersion);
writer.WriteOptionalElementString("whisper_model_hash", obj.WhisperModelHash);
writer.WriteOptionalElementString("whisper_model_name", obj.WhisperModelName);
writer.WriteOptionalElementString("whisper_version", obj.WhisperVersion);
// OCR-Related
writer.WriteOptionalElementString("cloth_cover_detection_module_version", obj.ClothCoverDetectionModuleVersion);
writer.WriteOptionalElementString("hocr_char_to_word_hocr_version", obj.hOCRCharToWordhOCRVersion);
writer.WriteOptionalElementString("hocr_char_to_word_module_version", obj.hOCRCharToWordModuleVersion);
writer.WriteOptionalElementString("hocr_fts_text_hocr_version", obj.hOCRFtsTexthOCRVersion);
writer.WriteOptionalElementString("hocr_fts_text_module_version", obj.hOCRFtsTextModuleVersion);
writer.WriteOptionalElementString("hocr_pageindex_hocr_version", obj.hOCRPageIndexhOCRVersion);
writer.WriteOptionalElementString("hocr_pageindex_module_version", obj.hOCRPageIndexModuleVersion);
writer.WriteOptionalElementString("ocr", obj.TesseractOCR);
writer.WriteOptionalElementString("ocr_converted", obj.TesseractOCRConverted);
writer.WriteOptionalElementString("ocr_detected_lang", obj.TesseractOCRDetectedLang);
writer.WriteOptionalElementString("ocr_detected_lang_conf", obj.TesseractOCRDetectedLangConf);
writer.WriteOptionalElementString("ocr_detected_script", obj.TesseractOCRDetectedScript);
writer.WriteOptionalElementString("ocr_detected_script_conf", obj.TesseractOCRDetectedScriptConf);
writer.WriteOptionalElementString("ocr_module_version", obj.TesseractOCRModuleVersion);
writer.WriteOptionalElementString("ocr_parameters", obj.TesseractOCRParameters);
writer.WriteOptionalElementString("pdf_module_version", obj.PDFModuleVersion);
writer.WriteOptionalElementString("word_conf_0_10", obj.WordConfidenceInterval0To10);
writer.WriteOptionalElementString("word_conf_11_20", obj.WordConfidenceInterval11To20);
writer.WriteOptionalElementString("word_conf_21_30", obj.WordConfidenceInterval21To30);
writer.WriteOptionalElementString("word_conf_31_40", obj.WordConfidenceInterval31To40);
writer.WriteOptionalElementString("word_conf_41_50", obj.WordConfidenceInterval41To50);
writer.WriteOptionalElementString("word_conf_51_60", obj.WordConfidenceInterval51To60);
writer.WriteOptionalElementString("word_conf_61_70", obj.WordConfidenceInterval61To70);
writer.WriteOptionalElementString("word_conf_71_80", obj.WordConfidenceInterval71To80);
writer.WriteOptionalElementString("word_conf_81_90", obj.WordConfidenceInterval81To90);
writer.WriteOptionalElementString("word_conf_91_100", obj.WordConfidenceInterval91To100);
// Media-Related
writer.WriteOptionalElementString("album", obj.Album);
writer.WriteOptionalElementString("artist", obj.Artist);
writer.WriteOptionalElementString("bitrate", obj.Bitrate);
writer.WriteOptionalElementString("creator", obj.Creator);
writer.WriteOptionalElementString("height", obj.Height);
writer.WriteOptionalElementString("length", obj.Length);
writer.WriteOptionalElementString("preview-image", obj.PreviewImage);
writer.WriteOptionalElementString("rotation", obj.Rotation);
writer.WriteOptionalElementString("title", obj.Title);
writer.WriteOptionalElementString("track", obj.Track);
writer.WriteOptionalElementString("width", obj.Width);
writer.WriteEndElement();
}
/// <summary>
/// Write a Files to an XmlTextWriter
/// </summary>
/// <param name="obj">Files to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteFiles(Files obj, XmlTextWriter writer)
{
writer.WriteStartElement("files");
if (obj.File is not null && obj.File.Length > 0)
{
foreach (var file in obj.File)
{
WriteFile(file, writer);
}
}
writer.WriteEndElement();
}
}
}

837
SabreTools.Serialization.Writers/Listxml.cs
View File

@@ -1,9 +1,842 @@
using System.IO;
using System.Text;
using System.Xml;
using SabreTools.Data.Models.Listxml;
using SabreTools.IO.Extensions;
using SabreTools.Text.Extensions;
namespace SabreTools.Serialization.Writers
{
public class Listxml : XmlFile<Mame>
public class Listxml : BaseBinaryWriter<Mame>
{
// All logic taken care of in the base class
/// <inheritdoc/>
public override Stream? SerializeStream(Mame? obj)
{
// If the metadata file is null
if (obj is null)
return null;
// Setup the writer and output
var stream = new MemoryStream();
var writer = new XmlTextWriter(stream, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
// Write the Mame, if it exists
WriteMame(obj, writer);
writer.Flush();
// Return the stream
stream.SeekIfPossible(0, SeekOrigin.Begin);
return stream;
}
/// <summary>
/// Write a Mame to an XmlTextWriter
/// </summary>
/// <param name="obj">Mame to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteMame(Mame obj, XmlTextWriter writer)
{
writer.WriteStartElement("mame");
writer.WriteOptionalAttributeString("build", obj.Build);
writer.WriteOptionalAttributeString("debug", obj.Debug);
writer.WriteRequiredAttributeString("mameconfig", obj.MameConfig);
if (obj.Game is not null && obj.Game.Length > 0)
{
foreach (var gameBase in obj.Game)
{
WriteGameBase(gameBase, writer);
}
}
writer.WriteEndElement();
}
#region Items
/// <summary>
/// Write a Adjuster to an XmlTextWriter
/// </summary>
/// <param name="obj">Adjuster to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteAdjuster(Adjuster obj, XmlTextWriter writer)
{
writer.WriteStartElement("adjuster");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Analog to an XmlTextWriter
/// </summary>
/// <param name="obj">Analog to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteAnalog(Analog obj, XmlTextWriter writer)
{
writer.WriteStartElement("analog");
writer.WriteRequiredAttributeString("mask", obj.Mask);
writer.WriteEndElement();
}
/// <summary>
/// Write a BiosSet to an XmlTextWriter
/// </summary>
/// <param name="obj">BiosSet to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteBiosSet(BiosSet obj, XmlTextWriter writer)
{
writer.WriteStartElement("biosset");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("description", obj.Description);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteEndElement();
}
/// <summary>
/// Write a Chip to an XmlTextWriter
/// </summary>
/// <param name="obj">Chip to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteChip(Chip obj, XmlTextWriter writer)
{
writer.WriteStartElement("chip");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("soundonly", obj.SoundOnly);
writer.WriteOptionalAttributeString("clock", obj.Clock);
writer.WriteEndElement();
}
/// <summary>
/// Write a Condition to an XmlTextWriter
/// </summary>
/// <param name="obj">Condition to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteCondition(Condition obj, XmlTextWriter writer)
{
writer.WriteStartElement("condition");
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("mask", obj.Mask);
writer.WriteRequiredAttributeString("relation", obj.Relation);
writer.WriteRequiredAttributeString("value", obj.Value);
writer.WriteEndElement();
}
/// <summary>
/// Write a Configuration to an XmlTextWriter
/// </summary>
/// <param name="obj">Configuration to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteConfiguration(Configuration obj, XmlTextWriter writer)
{
writer.WriteStartElement("configuration");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteOptionalAttributeString("mask", obj.Mask);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
if (obj.ConfLocation is not null && obj.ConfLocation.Length > 0)
{
foreach (var confLocation in obj.ConfLocation)
{
WriteConfLocation(confLocation, writer);
}
}
if (obj.ConfSetting is not null && obj.ConfSetting.Length > 0)
{
foreach (var confSetting in obj.ConfSetting)
{
WriteConfSetting(confSetting, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a ConfLocation to an XmlTextWriter
/// </summary>
/// <param name="obj">ConfLocation to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteConfLocation(ConfLocation obj, XmlTextWriter writer)
{
writer.WriteStartElement("conflocation");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("number", obj.Number);
writer.WriteOptionalAttributeString("inverted", obj.Inverted);
writer.WriteEndElement();
}
/// <summary>
/// Write a ConfSetting to an XmlTextWriter
/// </summary>
/// <param name="obj">ConfSetting to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteConfSetting(ConfSetting obj, XmlTextWriter writer)
{
writer.WriteStartElement("confsetting");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("value", obj.Value);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Control to an XmlTextWriter
/// </summary>
/// <param name="obj">Control to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteControl(Control obj, XmlTextWriter writer)
{
writer.WriteStartElement("control");
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("player", obj.Player);
writer.WriteOptionalAttributeString("buttons", obj.Buttons);
writer.WriteOptionalAttributeString("reqbuttons", obj.ReqButtons);
writer.WriteOptionalAttributeString("minimum", obj.Minimum);
writer.WriteOptionalAttributeString("maximum", obj.Maximum);
writer.WriteOptionalAttributeString("sensitivity", obj.Sensitivity);
writer.WriteOptionalAttributeString("keydelta", obj.KeyDelta);
writer.WriteOptionalAttributeString("reverse", obj.Reverse);
writer.WriteOptionalAttributeString("ways", obj.Ways);
writer.WriteOptionalAttributeString("ways2", obj.Ways2);
writer.WriteOptionalAttributeString("ways3", obj.Ways3);
writer.WriteEndElement();
}
/// <summary>
/// Write a Device to an XmlTextWriter
/// </summary>
/// <param name="obj">Device to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDevice(Device obj, XmlTextWriter writer)
{
writer.WriteStartElement("device");
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("tag", obj.Tag);
writer.WriteOptionalAttributeString("fixed_image", obj.FixedImage);
writer.WriteOptionalAttributeString("mandatory", obj.Mandatory);
writer.WriteOptionalAttributeString("interface", obj.Interface);
if (obj.Instance is not null)
WriteInstance(obj.Instance, writer);
if (obj.Extension is not null && obj.Extension.Length > 0)
{
foreach (var extension in obj.Extension)
{
WriteExtension(extension, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a DeviceRef to an XmlTextWriter
/// </summary>
/// <param name="obj">DeviceRef to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDeviceRef(DeviceRef obj, XmlTextWriter writer)
{
writer.WriteStartElement("device_ref");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a DipLocation to an XmlTextWriter
/// </summary>
/// <param name="obj">DipLocation to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipLocation(DipLocation obj, XmlTextWriter writer)
{
writer.WriteStartElement("diplocation");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("number", obj.Number);
writer.WriteOptionalAttributeString("inverted", obj.Inverted);
writer.WriteEndElement();
}
/// <summary>
/// Write a DipSwitch to an XmlTextWriter
/// </summary>
/// <param name="obj">DipSwitch to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipSwitch(DipSwitch obj, XmlTextWriter writer)
{
writer.WriteStartElement("dipswitch");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteOptionalAttributeString("mask", obj.Mask);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
if (obj.DipLocation is not null && obj.DipLocation.Length > 0)
{
foreach (var dipLocation in obj.DipLocation)
{
WriteDipLocation(dipLocation, writer);
}
}
if (obj.DipValue is not null && obj.DipValue.Length > 0)
{
foreach (var dipValue in obj.DipValue)
{
WriteDipValue(dipValue, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a DipValue to an XmlTextWriter
/// </summary>
/// <param name="obj">DipValue to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipValue(DipValue obj, XmlTextWriter writer)
{
writer.WriteStartElement("dipvalue");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("value", obj.Value);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Disk to an XmlTextWriter
/// </summary>
/// <param name="obj">Disk to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDisk(Disk obj, XmlTextWriter writer)
{
writer.WriteStartElement("disk");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("md5", obj.MD5);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("merge", obj.Merge);
writer.WriteOptionalAttributeString("region", obj.Region);
writer.WriteOptionalAttributeString("index", obj.Index);
writer.WriteOptionalAttributeString("writable", obj.Writable);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("optional", obj.Optional);
writer.WriteEndElement();
}
/// <summary>
/// Write a Display to an XmlTextWriter
/// </summary>
/// <param name="obj">Display to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDisplay(Display obj, XmlTextWriter writer)
{
writer.WriteStartElement("display");
writer.WriteOptionalAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("rotate", obj.Rotate);
writer.WriteOptionalAttributeString("flipx", obj.FlipX);
writer.WriteOptionalAttributeString("width", obj.Width);
writer.WriteOptionalAttributeString("height", obj.Height);
writer.WriteRequiredAttributeString("refresh", obj.Refresh);
writer.WriteOptionalAttributeString("pixclock", obj.PixClock);
writer.WriteOptionalAttributeString("htotal", obj.HTotal);
writer.WriteOptionalAttributeString("hbend", obj.HBEnd);
writer.WriteOptionalAttributeString("hbstart", obj.HBStart);
writer.WriteOptionalAttributeString("vtotal", obj.VTotal);
writer.WriteOptionalAttributeString("vbend", obj.VBEnd);
writer.WriteOptionalAttributeString("vbstart", obj.VBStart);
writer.WriteEndElement();
}
/// <summary>
/// Write a Driver to an XmlTextWriter
/// </summary>
/// <param name="obj">Driver to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDriver(Driver obj, XmlTextWriter writer)
{
writer.WriteStartElement("driver");
writer.WriteRequiredAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("color", obj.Color);
writer.WriteOptionalAttributeString("sound", obj.Sound);
writer.WriteOptionalAttributeString("palettesize", obj.PaletteSize);
writer.WriteRequiredAttributeString("emulation", obj.Emulation);
writer.WriteRequiredAttributeString("cocktail", obj.Cocktail);
writer.WriteRequiredAttributeString("savestate", obj.SaveState);
writer.WriteOptionalAttributeString("requiresartwork", obj.RequiresArtwork);
writer.WriteOptionalAttributeString("unofficial", obj.Unofficial);
writer.WriteOptionalAttributeString("nosoundhardware", obj.NoSoundHardware);
writer.WriteOptionalAttributeString("incomplete", obj.Incomplete);
writer.WriteEndElement();
}
/// <summary>
/// Write a Extension to an XmlTextWriter
/// </summary>
/// <param name="obj">Extension to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteExtension(Extension obj, XmlTextWriter writer)
{
writer.WriteStartElement("extension");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a Feature to an XmlTextWriter
/// </summary>
/// <param name="obj">Feature to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteFeature(Feature obj, XmlTextWriter writer)
{
writer.WriteStartElement("feature");
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("overall", obj.Overall);
writer.WriteEndElement();
}
/// <summary>
/// Write a GameBase to an XmlTextWriter
/// </summary>
/// <param name="obj">GameBase to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteGameBase(GameBase obj, XmlTextWriter writer)
{
if (obj is Game)
writer.WriteStartElement("game");
else if (obj is Machine)
writer.WriteStartElement("machine");
else
return;
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("sourcefile", obj.SourceFile);
writer.WriteOptionalAttributeString("isbios", obj.IsBios);
writer.WriteOptionalAttributeString("isdevice", obj.IsDevice);
writer.WriteOptionalAttributeString("ismechanical", obj.IsMechanical);
writer.WriteOptionalAttributeString("runnable", obj.Runnable);
writer.WriteOptionalAttributeString("cloneof", obj.CloneOf);
writer.WriteOptionalAttributeString("romof", obj.RomOf);
writer.WriteOptionalAttributeString("sampleof", obj.SampleOf);
writer.WriteRequiredElementString("description", obj.Description);
writer.WriteOptionalElementString("year", obj.Year);
writer.WriteOptionalElementString("manufacturer", obj.Manufacturer);
writer.WriteOptionalElementString("history", obj.History);
if (obj.BiosSet is not null && obj.BiosSet.Length > 0)
{
foreach (var biosSet in obj.BiosSet)
{
WriteBiosSet(biosSet, writer);
}
}
if (obj.Rom is not null && obj.Rom.Length > 0)
{
foreach (var rom in obj.Rom)
{
WriteRom(rom, writer);
}
}
if (obj.Disk is not null && obj.Disk.Length > 0)
{
foreach (var disk in obj.Disk)
{
WriteDisk(disk, writer);
}
}
if (obj.DeviceRef is not null && obj.DeviceRef.Length > 0)
{
foreach (var deviceRef in obj.DeviceRef)
{
WriteDeviceRef(deviceRef, writer);
}
}
if (obj.Sample is not null && obj.Sample.Length > 0)
{
foreach (var sample in obj.Sample)
{
WriteSample(sample, writer);
}
}
if (obj.Chip is not null && obj.Chip.Length > 0)
{
foreach (var chip in obj.Chip)
{
WriteChip(chip, writer);
}
}
if (obj.Display is not null && obj.Display.Length > 0)
{
foreach (var display in obj.Display)
{
WriteDisplay(display, writer);
}
}
if (obj.Video is not null && obj.Video.Length > 0)
{
foreach (var video in obj.Video)
{
WriteVideo(video, writer);
}
}
if (obj.Sound is not null)
WriteSound(obj.Sound, writer);
if (obj.Input is not null)
WriteInput(obj.Input, writer);
if (obj.DipSwitch is not null && obj.DipSwitch.Length > 0)
{
foreach (var dipSwitch in obj.DipSwitch)
{
WriteDipSwitch(dipSwitch, writer);
}
}
if (obj.Configuration is not null && obj.Configuration.Length > 0)
{
foreach (var configuration in obj.Configuration)
{
WriteConfiguration(configuration, writer);
}
}
if (obj.Port is not null && obj.Port.Length > 0)
{
foreach (var port in obj.Port)
{
WritePort(port, writer);
}
}
if (obj.Adjuster is not null && obj.Adjuster.Length > 0)
{
foreach (var adjuster in obj.Adjuster)
{
WriteAdjuster(adjuster, writer);
}
}
if (obj.Driver is not null)
WriteDriver(obj.Driver, writer);
if (obj.Feature is not null && obj.Feature.Length > 0)
{
foreach (var feature in obj.Feature)
{
WriteFeature(feature, writer);
}
}
if (obj.Device is not null && obj.Device.Length > 0)
{
foreach (var device in obj.Device)
{
WriteDevice(device, writer);
}
}
if (obj.Slot is not null && obj.Slot.Length > 0)
{
foreach (var slot in obj.Slot)
{
WriteSlot(slot, writer);
}
}
if (obj.SoftwareList is not null && obj.SoftwareList.Length > 0)
{
foreach (var softwareList in obj.SoftwareList)
{
WriteSoftwareList(softwareList, writer);
}
}
if (obj.RamOption is not null && obj.RamOption.Length > 0)
{
foreach (var ramOption in obj.RamOption)
{
WriteRamOption(ramOption, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Input to an XmlTextWriter
/// </summary>
/// <param name="obj">Input to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteInput(Input obj, XmlTextWriter writer)
{
writer.WriteStartElement("input");
writer.WriteOptionalAttributeString("service", obj.Service);
writer.WriteOptionalAttributeString("tilt", obj.Tilt);
writer.WriteRequiredAttributeString("players", obj.Players);
writer.WriteOptionalAttributeString("control", obj.ControlAttr);
writer.WriteOptionalAttributeString("buttons", obj.Buttons);
writer.WriteOptionalAttributeString("coins", obj.Coins);
if (obj.Control is not null && obj.Control.Length > 0)
{
foreach (var control in obj.Control)
{
WriteControl(control, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Instance to an XmlTextWriter
/// </summary>
/// <param name="obj">Instance to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteInstance(Instance obj, XmlTextWriter writer)
{
writer.WriteStartElement("instance");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("briefname", obj.BriefName);
writer.WriteEndElement();
}
/// <summary>
/// Write a Port to an XmlTextWriter
/// </summary>
/// <param name="obj">Port to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WritePort(Port obj, XmlTextWriter writer)
{
writer.WriteStartElement("port");
writer.WriteRequiredAttributeString("tag", obj.Tag);
if (obj.Analog is not null && obj.Analog.Length > 0)
{
foreach (var analog in obj.Analog)
{
WriteAnalog(analog, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a RamOption to an XmlTextWriter
/// </summary>
/// <param name="obj">RamOption to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRamOption(RamOption obj, XmlTextWriter writer)
{
writer.WriteStartElement("ramoption");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Content is not null)
writer.WriteValue(obj.Content);
writer.WriteEndElement();
}
/// <summary>
/// Write a Rom to an XmlTextWriter
/// </summary>
/// <param name="obj">Rom to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRom(Rom obj, XmlTextWriter writer)
{
writer.WriteStartElement("rom");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("bios", obj.Bios);
writer.WriteRequiredAttributeString("size", obj.Size);
writer.WriteOptionalAttributeString("crc", obj.CRC);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("merge", obj.Merge);
writer.WriteOptionalAttributeString("region", obj.Region);
writer.WriteOptionalAttributeString("offset", obj.Offset);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("optional", obj.Optional);
writer.WriteOptionalAttributeString("dispose", obj.Dispose);
writer.WriteOptionalAttributeString("soundonly", obj.SoundOnly);
writer.WriteEndElement();
}
/// <summary>
/// Write a Sample to an XmlTextWriter
/// </summary>
/// <param name="obj">Sample to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSample(Sample obj, XmlTextWriter writer)
{
writer.WriteStartElement("sample");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a Slot to an XmlTextWriter
/// </summary>
/// <param name="obj">Slot to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSlot(Slot obj, XmlTextWriter writer)
{
writer.WriteStartElement("slot");
writer.WriteRequiredAttributeString("name", obj.Name);
if (obj.SlotOption is not null && obj.SlotOption.Length > 0)
{
foreach (var slotOption in obj.SlotOption)
{
WriteSlotOption(slotOption, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a SlotOption to an XmlTextWriter
/// </summary>
/// <param name="obj">SlotOption to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSlotOption(SlotOption obj, XmlTextWriter writer)
{
writer.WriteStartElement("slotoption");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("devname", obj.DevName);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteEndElement();
}
/// <summary>
/// Write a SoftwareList to an XmlTextWriter
/// </summary>
/// <param name="obj">SoftwareList to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSoftwareList(Data.Models.Listxml.SoftwareList obj, XmlTextWriter writer)
{
writer.WriteStartElement("softwarelist");
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("filter", obj.Filter);
writer.WriteEndElement();
}
/// <summary>
/// Write a Sound to an XmlTextWriter
/// </summary>
/// <param name="obj">Sound to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSound(Sound obj, XmlTextWriter writer)
{
writer.WriteStartElement("sound");
writer.WriteRequiredAttributeString("channels", obj.Channels);
writer.WriteEndElement();
}
/// <summary>
/// Write a Video to an XmlTextWriter
/// </summary>
/// <param name="obj">Video to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteVideo(Video obj, XmlTextWriter writer)
{
writer.WriteStartElement("video");
writer.WriteRequiredAttributeString("screen", obj.Screen);
writer.WriteRequiredAttributeString("orientation", obj.Orientation);
writer.WriteOptionalAttributeString("width", obj.Width);
writer.WriteOptionalAttributeString("height", obj.Height);
writer.WriteOptionalAttributeString("aspectx", obj.AspectX);
writer.WriteOptionalAttributeString("aspecty", obj.AspectY);
writer.WriteRequiredAttributeString("refresh", obj.Refresh);
writer.WriteEndElement();
}
#endregion
}
}

538
SabreTools.Serialization.Writers/Logiqx.cs
View File

@@ -1,9 +1,13 @@
using System.IO;
using System.Text;
using System.Xml;
using SabreTools.Data.Models.Logiqx;
using SabreTools.IO.Extensions;
using SabreTools.Text.Extensions;
namespace SabreTools.Serialization.Writers
{
public class Logiqx : XmlFile<Datafile>
public class Logiqx : BaseBinaryWriter<Datafile>
{
#region Constants
@@ -29,27 +33,519 @@ namespace SabreTools.Serialization.Writers
#endregion
#region IByteWriter
/// <inheritdoc cref="XmlFile.SerializeArray(T?, string?, string?, string?, string?)" />
public override byte[]? SerializeArray(Datafile? obj)
=> SerializeArray(obj, DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSysId);
#endregion
#region IFileWriter
/// <inheritdoc cref="XmlFile.Serialize(T?, string?, string?, string?, string?, string?)" />
public override bool SerializeFile(Datafile? obj, string? path)
=> Serialize(obj, path, DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSysId);
#endregion
#region IStreamWriter
/// <inheritdoc cref="XmlFile.Serialize(T?, string?, string?, string?, string?)" />
/// <inheritdoc/>
public override Stream? SerializeStream(Datafile? obj)
=> Serialize(obj, DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSysId);
{
// If the metadata file is null
if (obj is null)
return null;
// Setup the writer and output
var stream = new MemoryStream();
var writer = new XmlTextWriter(stream, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
// Write document type
writer.WriteDocType(DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSubset);
// Write the SoftwareDb, if it exists
WriteDatafile(obj, writer);
writer.Flush();
// Return the stream
stream.SeekIfPossible(0, SeekOrigin.Begin);
return stream;
}
/// <summary>
/// Write a Datafile to an XmlTextWriter
/// </summary>
/// <param name="obj">Datafile to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDatafile(Datafile obj, XmlTextWriter writer)
{
writer.WriteStartElement("datafile");
writer.WriteOptionalAttributeString("build", obj.Build);
writer.WriteOptionalAttributeString("debug", obj.Debug);
// TODO: Fix schema location writing
// writer.WriteOptionalAttributeString("schemaLocation", obj.SchemaLocation);
if (obj.Header is not null)
WriteHeader(obj.Header, writer);
if (obj.Game is not null && obj.Game.Length > 0)
{
foreach (var gameBase in obj.Game)
{
WriteGameBase(gameBase, writer);
}
}
if (obj.Dir is not null && obj.Dir.Length > 0)
{
foreach (var dir in obj.Dir)
{
WriteDir(dir, writer);
}
}
writer.WriteEndElement();
}
#region Header
/// <summary>
/// Write a ClrMamePro to an XmlTextWriter
/// </summary>
/// <param name="obj">ClrMamePro to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteClrMamePro(Data.Models.Logiqx.ClrMamePro obj, XmlTextWriter writer)
{
writer.WriteStartElement("clrmamepro");
writer.WriteOptionalAttributeString("header", obj.Header);
writer.WriteOptionalAttributeString("forcemerging", obj.ForceMerging);
writer.WriteOptionalAttributeString("forcenodump", obj.ForceNodump);
writer.WriteOptionalAttributeString("forcepacking", obj.ForcePacking);
writer.WriteEndElement();
}
/// <summary>
/// Write a Header to an XmlTextWriter
/// </summary>
/// <param name="obj">Header to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteHeader(Header obj, XmlTextWriter writer)
{
writer.WriteStartElement("header");
writer.WriteOptionalElementString("id", obj.Id);
writer.WriteRequiredElementString("name", obj.Name);
writer.WriteRequiredElementString("description", obj.Description);
writer.WriteOptionalElementString("rootdir", obj.RootDir);
writer.WriteOptionalElementString("category", obj.Category);
writer.WriteRequiredElementString("version", obj.Version);
writer.WriteOptionalElementString("date", obj.Date);
writer.WriteRequiredElementString("author", obj.Author);
writer.WriteOptionalElementString("email", obj.Email);
writer.WriteOptionalElementString("homepage", obj.Homepage);
writer.WriteOptionalElementString("url", obj.Url);
writer.WriteOptionalElementString("comment", obj.Comment);
writer.WriteOptionalElementString("type", obj.Type);
if (obj.ClrMamePro is not null)
WriteClrMamePro(obj.ClrMamePro, writer);
if (obj.RomCenter is not null)
WriteRomCenter(obj.RomCenter, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a RomCenter to an XmlTextWriter
/// </summary>
/// <param name="obj">RomCenter to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRomCenter(Data.Models.Logiqx.RomCenter obj, XmlTextWriter writer)
{
writer.WriteStartElement("romcenter");
writer.WriteOptionalAttributeString("plugin", obj.Plugin);
writer.WriteOptionalAttributeString("rommode", obj.RomMode);
writer.WriteOptionalAttributeString("biosmode", obj.BiosMode);
writer.WriteOptionalAttributeString("samplemode", obj.SampleMode);
writer.WriteOptionalAttributeString("lockrommode", obj.LockRomMode);
writer.WriteOptionalAttributeString("lockbiosmode", obj.LockBiosMode);
writer.WriteOptionalAttributeString("locksamplemode", obj.LockSampleMode);
writer.WriteEndElement();
}
#endregion
#region Items
/// <summary>
/// Write a Archive to an XmlTextWriter
/// </summary>
/// <param name="obj">Archive to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteArchive(Archive obj, XmlTextWriter writer)
{
writer.WriteStartElement("archive");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a BiosSet to an XmlTextWriter
/// </summary>
/// <param name="obj">BiosSet to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteBiosSet(BiosSet obj, XmlTextWriter writer)
{
writer.WriteStartElement("biosset");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("description", obj.Description);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteEndElement();
}
/// <summary>
/// Write a DeviceRef to an XmlTextWriter
/// </summary>
/// <param name="obj">DeviceRef to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDeviceRef(DeviceRef obj, XmlTextWriter writer)
{
writer.WriteStartElement("device_ref");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a Dir to an XmlTextWriter
/// </summary>
/// <param name="obj">Dir to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDir(Dir obj, XmlTextWriter writer)
{
writer.WriteStartElement("dir");
writer.WriteRequiredAttributeString("name", obj.Name);
if (obj.Subdir is not null && obj.Subdir.Length > 0)
{
foreach (var subdir in obj.Subdir)
{
WriteDir(subdir, writer);
}
}
if (obj.Game is not null && obj.Game.Length > 0)
{
foreach (var game in obj.Game)
{
WriteGameBase(game, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Disk to an XmlTextWriter
/// </summary>
/// <param name="obj">Disk to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDisk(Disk obj, XmlTextWriter writer)
{
writer.WriteStartElement("disk");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("md5", obj.MD5);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("merge", obj.Merge);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("region", obj.Region);
writer.WriteEndElement();
}
/// <summary>
/// Write a Driver to an XmlTextWriter
/// </summary>
/// <param name="obj">Driver to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDriver(Driver obj, XmlTextWriter writer)
{
writer.WriteStartElement("driver");
writer.WriteRequiredAttributeString("status", obj.Status);
writer.WriteRequiredAttributeString("emulation", obj.Emulation);
writer.WriteRequiredAttributeString("cocktail", obj.Cocktail);
writer.WriteRequiredAttributeString("savestate", obj.SaveState);
writer.WriteOptionalAttributeString("requiresartwork", obj.RequiresArtwork);
writer.WriteOptionalAttributeString("unofficial", obj.Unofficial);
writer.WriteOptionalAttributeString("nosoundhardware", obj.NoSoundHardware);
writer.WriteOptionalAttributeString("incomplete", obj.Incomplete);
writer.WriteEndElement();
}
/// <summary>
/// Write a GameBase to an XmlTextWriter
/// </summary>
/// <param name="obj">GameBase to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteGameBase(GameBase obj, XmlTextWriter writer)
{
if (obj is Game)
writer.WriteStartElement("game");
else if (obj is Machine)
writer.WriteStartElement("machine");
else
return;
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("sourcefile", obj.SourceFile);
writer.WriteOptionalAttributeString("isbios", obj.IsBios);
writer.WriteOptionalAttributeString("isdevice", obj.IsDevice);
writer.WriteOptionalAttributeString("ismechanical", obj.IsMechanical);
writer.WriteOptionalAttributeString("cloneof", obj.CloneOf);
writer.WriteOptionalAttributeString("romof", obj.RomOf);
writer.WriteOptionalAttributeString("sampleof", obj.SampleOf);
writer.WriteOptionalAttributeString("board", obj.Board);
writer.WriteOptionalAttributeString("rebuildto", obj.RebuildTo);
writer.WriteOptionalAttributeString("id", obj.Id);
writer.WriteOptionalAttributeString("cloneofid", obj.CloneOfId);
writer.WriteOptionalAttributeString("runnable", obj.Runnable);
if (obj.Comment is not null && obj.Comment.Length > 0)
{
foreach (var comment in obj.Comment)
{
writer.WriteRequiredElementString("comment", comment);
}
}
writer.WriteRequiredElementString("description", obj.Description);
writer.WriteOptionalElementString("year", obj.Year);
writer.WriteOptionalElementString("manufacturer", obj.Manufacturer);
writer.WriteOptionalElementString("publisher", obj.Publisher);
if (obj.Category is not null && obj.Category.Length > 0)
{
foreach (var category in obj.Category)
{
writer.WriteRequiredElementString("category", category);
}
}
if (obj.Trurip is not null)
WriteTrurip(obj.Trurip, writer);
if (obj.Release is not null && obj.Release.Length > 0)
{
foreach (var release in obj.Release)
{
WriteRelease(release, writer);
}
}
if (obj.BiosSet is not null && obj.BiosSet.Length > 0)
{
foreach (var biosSet in obj.BiosSet)
{
WriteBiosSet(biosSet, writer);
}
}
if (obj.Rom is not null && obj.Rom.Length > 0)
{
foreach (var rom in obj.Rom)
{
WriteRom(rom, writer);
}
}
if (obj.Disk is not null && obj.Disk.Length > 0)
{
foreach (var disk in obj.Disk)
{
WriteDisk(disk, writer);
}
}
if (obj.Media is not null && obj.Media.Length > 0)
{
foreach (var media in obj.Media)
{
WriteMedia(media, writer);
}
}
if (obj.DeviceRef is not null && obj.DeviceRef.Length > 0)
{
foreach (var deviceRef in obj.DeviceRef)
{
WriteDeviceRef(deviceRef, writer);
}
}
if (obj.Sample is not null && obj.Sample.Length > 0)
{
foreach (var sample in obj.Sample)
{
WriteSample(sample, writer);
}
}
if (obj.Archive is not null && obj.Archive.Length > 0)
{
foreach (var archive in obj.Archive)
{
WriteArchive(archive, writer);
}
}
if (obj.Driver is not null)
WriteDriver(obj.Driver, writer);
if (obj.SoftwareList is not null && obj.SoftwareList.Length > 0)
{
foreach (var softwareList in obj.SoftwareList)
{
WriteSoftwareList(softwareList, writer);
}
}
writer.WriteOptionalElementString("url", obj.Url);
writer.WriteOptionalElementString("hash", obj.Hash);
writer.WriteEndElement();
}
/// <summary>
/// Write a Media to an XmlTextWriter
/// </summary>
/// <param name="obj">Media to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteMedia(Media obj, XmlTextWriter writer)
{
writer.WriteStartElement("media");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("md5", obj.MD5);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("sha256", obj.SHA256);
writer.WriteOptionalAttributeString("spamsum", obj.SpamSum);
writer.WriteEndElement();
}
/// <summary>
/// Write a Release to an XmlTextWriter
/// </summary>
/// <param name="obj">Release to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRelease(Release obj, XmlTextWriter writer)
{
writer.WriteStartElement("release");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("region", obj.Region);
writer.WriteOptionalAttributeString("language", obj.Language);
writer.WriteOptionalAttributeString("date", obj.Date);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteEndElement();
}
/// <summary>
/// Write a Rom to an XmlTextWriter
/// </summary>
/// <param name="obj">Rom to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRom(Rom obj, XmlTextWriter writer)
{
writer.WriteStartElement("rom");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("size", obj.Size);
writer.WriteOptionalAttributeString("crc16", obj.CRC16);
writer.WriteOptionalAttributeString("crc", obj.CRC);
writer.WriteOptionalAttributeString("crc64", obj.CRC64);
writer.WriteOptionalAttributeString("md2", obj.MD2);
writer.WriteOptionalAttributeString("md4", obj.MD4);
writer.WriteOptionalAttributeString("md5", obj.MD5);
writer.WriteOptionalAttributeString("ripemd128", obj.RIPEMD128);
writer.WriteOptionalAttributeString("ripemd160", obj.RIPEMD160);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("sha256", obj.SHA256);
writer.WriteOptionalAttributeString("sha384", obj.SHA384);
writer.WriteOptionalAttributeString("sha512", obj.SHA512);
writer.WriteOptionalAttributeString("spamsum", obj.SpamSum);
writer.WriteOptionalAttributeString("xxh3_64", obj.xxHash364);
writer.WriteOptionalAttributeString("xxh3_128", obj.xxHash3128);
writer.WriteOptionalAttributeString("merge", obj.Merge);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("serial", obj.Serial);
writer.WriteOptionalAttributeString("header", obj.Header);
writer.WriteOptionalAttributeString("date", obj.Date);
writer.WriteOptionalAttributeString("inverted", obj.Inverted);
writer.WriteOptionalAttributeString("mia", obj.MIA);
writer.WriteEndElement();
}
/// <summary>
/// Write a Sample to an XmlTextWriter
/// </summary>
/// <param name="obj">Sample to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSample(Sample obj, XmlTextWriter writer)
{
writer.WriteStartElement("sample");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a SoftwareList to an XmlTextWriter
/// </summary>
/// <param name="obj">SoftwareList to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSoftwareList(Data.Models.Logiqx.SoftwareList obj, XmlTextWriter writer)
{
writer.WriteStartElement("softwarelist");
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("filter", obj.Filter);
writer.WriteEndElement();
}
/// <summary>
/// Write a Trurip to an XmlTextWriter
/// </summary>
/// <param name="obj">Trurip to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteTrurip(Trurip obj, XmlTextWriter writer)
{
writer.WriteStartElement("trurip");
writer.WriteOptionalElementString("titleid", obj.TitleID);
writer.WriteOptionalElementString("publisher", obj.Publisher);
writer.WriteOptionalElementString("developer", obj.Developer);
writer.WriteOptionalElementString("year", obj.Year);
writer.WriteOptionalElementString("genre", obj.Genre);
writer.WriteOptionalElementString("subgenre", obj.Subgenre);
writer.WriteOptionalElementString("ratings", obj.Ratings);
writer.WriteOptionalElementString("score", obj.Score);
writer.WriteOptionalElementString("players", obj.Players);
writer.WriteOptionalElementString("enabled", obj.Enabled);
writer.WriteOptionalElementString("crc", obj.CRC);
writer.WriteOptionalElementString("source", obj.Source);
writer.WriteOptionalElementString("cloneof", obj.CloneOf);
writer.WriteOptionalElementString("relatedto", obj.RelatedTo);
writer.WriteEndElement();
}
#endregion
}

837
SabreTools.Serialization.Writers/M1.cs
View File

@@ -1,7 +1,840 @@
using System.IO;
using System.Text;
using System.Xml;
using SabreTools.Data.Models.Listxml;
using SabreTools.IO.Extensions;
using SabreTools.Text.Extensions;
namespace SabreTools.Serialization.Writers
{
public class M1 : XmlFile<Data.Models.Listxml.M1>
public class M1 : BaseBinaryWriter<Data.Models.Listxml.M1>
{
// All logic taken care of in the base class
/// <inheritdoc/>
public override Stream? SerializeStream(Data.Models.Listxml.M1? obj)
{
// If the metadata file is null
if (obj is null)
return null;
// Setup the writer and output
var stream = new MemoryStream();
var writer = new XmlTextWriter(stream, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
// Write the M1, if it exists
WriteM1(obj, writer);
writer.Flush();
// Return the stream
stream.SeekIfPossible(0, SeekOrigin.Begin);
return stream;
}
/// <summary>
/// Write a M1 to an XmlTextWriter
/// </summary>
/// <param name="obj">M1 to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteM1(Data.Models.Listxml.M1 obj, XmlTextWriter writer)
{
writer.WriteStartElement("m1");
writer.WriteOptionalAttributeString("version", obj.Version);
if (obj.Game is not null && obj.Game.Length > 0)
{
foreach (var gameBase in obj.Game)
{
WriteGameBase(gameBase, writer);
}
}
writer.WriteEndElement();
}
#region Items
/// <summary>
/// Write a Adjuster to an XmlTextWriter
/// </summary>
/// <param name="obj">Adjuster to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteAdjuster(Adjuster obj, XmlTextWriter writer)
{
writer.WriteStartElement("adjuster");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Analog to an XmlTextWriter
/// </summary>
/// <param name="obj">Analog to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteAnalog(Analog obj, XmlTextWriter writer)
{
writer.WriteStartElement("analog");
writer.WriteRequiredAttributeString("mask", obj.Mask);
writer.WriteEndElement();
}
/// <summary>
/// Write a BiosSet to an XmlTextWriter
/// </summary>
/// <param name="obj">BiosSet to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteBiosSet(BiosSet obj, XmlTextWriter writer)
{
writer.WriteStartElement("biosset");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("description", obj.Description);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteEndElement();
}
/// <summary>
/// Write a Chip to an XmlTextWriter
/// </summary>
/// <param name="obj">Chip to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteChip(Chip obj, XmlTextWriter writer)
{
writer.WriteStartElement("chip");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("soundonly", obj.SoundOnly);
writer.WriteOptionalAttributeString("clock", obj.Clock);
writer.WriteEndElement();
}
/// <summary>
/// Write a Condition to an XmlTextWriter
/// </summary>
/// <param name="obj">Condition to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteCondition(Condition obj, XmlTextWriter writer)
{
writer.WriteStartElement("condition");
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("mask", obj.Mask);
writer.WriteRequiredAttributeString("relation", obj.Relation);
writer.WriteRequiredAttributeString("value", obj.Value);
writer.WriteEndElement();
}
/// <summary>
/// Write a Configuration to an XmlTextWriter
/// </summary>
/// <param name="obj">Configuration to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteConfiguration(Configuration obj, XmlTextWriter writer)
{
writer.WriteStartElement("configuration");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteOptionalAttributeString("mask", obj.Mask);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
if (obj.ConfLocation is not null && obj.ConfLocation.Length > 0)
{
foreach (var confLocation in obj.ConfLocation)
{
WriteConfLocation(confLocation, writer);
}
}
if (obj.ConfSetting is not null && obj.ConfSetting.Length > 0)
{
foreach (var confSetting in obj.ConfSetting)
{
WriteConfSetting(confSetting, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a ConfLocation to an XmlTextWriter
/// </summary>
/// <param name="obj">ConfLocation to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteConfLocation(ConfLocation obj, XmlTextWriter writer)
{
writer.WriteStartElement("conflocation");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("number", obj.Number);
writer.WriteOptionalAttributeString("inverted", obj.Inverted);
writer.WriteEndElement();
}
/// <summary>
/// Write a ConfSetting to an XmlTextWriter
/// </summary>
/// <param name="obj">ConfSetting to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteConfSetting(ConfSetting obj, XmlTextWriter writer)
{
writer.WriteStartElement("confsetting");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("value", obj.Value);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Control to an XmlTextWriter
/// </summary>
/// <param name="obj">Control to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteControl(Control obj, XmlTextWriter writer)
{
writer.WriteStartElement("control");
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("player", obj.Player);
writer.WriteOptionalAttributeString("buttons", obj.Buttons);
writer.WriteOptionalAttributeString("reqbuttons", obj.ReqButtons);
writer.WriteOptionalAttributeString("minimum", obj.Minimum);
writer.WriteOptionalAttributeString("maximum", obj.Maximum);
writer.WriteOptionalAttributeString("sensitivity", obj.Sensitivity);
writer.WriteOptionalAttributeString("keydelta", obj.KeyDelta);
writer.WriteOptionalAttributeString("reverse", obj.Reverse);
writer.WriteOptionalAttributeString("ways", obj.Ways);
writer.WriteOptionalAttributeString("ways2", obj.Ways2);
writer.WriteOptionalAttributeString("ways3", obj.Ways3);
writer.WriteEndElement();
}
/// <summary>
/// Write a Device to an XmlTextWriter
/// </summary>
/// <param name="obj">Device to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDevice(Device obj, XmlTextWriter writer)
{
writer.WriteStartElement("device");
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("tag", obj.Tag);
writer.WriteOptionalAttributeString("fixed_image", obj.FixedImage);
writer.WriteOptionalAttributeString("mandatory", obj.Mandatory);
writer.WriteOptionalAttributeString("interface", obj.Interface);
if (obj.Instance is not null)
WriteInstance(obj.Instance, writer);
if (obj.Extension is not null && obj.Extension.Length > 0)
{
foreach (var extension in obj.Extension)
{
WriteExtension(extension, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a DeviceRef to an XmlTextWriter
/// </summary>
/// <param name="obj">DeviceRef to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDeviceRef(DeviceRef obj, XmlTextWriter writer)
{
writer.WriteStartElement("device_ref");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a DipLocation to an XmlTextWriter
/// </summary>
/// <param name="obj">DipLocation to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipLocation(DipLocation obj, XmlTextWriter writer)
{
writer.WriteStartElement("diplocation");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("number", obj.Number);
writer.WriteOptionalAttributeString("inverted", obj.Inverted);
writer.WriteEndElement();
}
/// <summary>
/// Write a DipSwitch to an XmlTextWriter
/// </summary>
/// <param name="obj">DipSwitch to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipSwitch(DipSwitch obj, XmlTextWriter writer)
{
writer.WriteStartElement("dipswitch");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteOptionalAttributeString("mask", obj.Mask);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
if (obj.DipLocation is not null && obj.DipLocation.Length > 0)
{
foreach (var dipLocation in obj.DipLocation)
{
WriteDipLocation(dipLocation, writer);
}
}
if (obj.DipValue is not null && obj.DipValue.Length > 0)
{
foreach (var dipValue in obj.DipValue)
{
WriteDipValue(dipValue, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a DipValue to an XmlTextWriter
/// </summary>
/// <param name="obj">DipValue to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipValue(DipValue obj, XmlTextWriter writer)
{
writer.WriteStartElement("dipvalue");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("value", obj.Value);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Disk to an XmlTextWriter
/// </summary>
/// <param name="obj">Disk to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDisk(Disk obj, XmlTextWriter writer)
{
writer.WriteStartElement("disk");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("md5", obj.MD5);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("merge", obj.Merge);
writer.WriteOptionalAttributeString("region", obj.Region);
writer.WriteOptionalAttributeString("index", obj.Index);
writer.WriteOptionalAttributeString("writable", obj.Writable);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("optional", obj.Optional);
writer.WriteEndElement();
}
/// <summary>
/// Write a Display to an XmlTextWriter
/// </summary>
/// <param name="obj">Display to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDisplay(Display obj, XmlTextWriter writer)
{
writer.WriteStartElement("display");
writer.WriteOptionalAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("rotate", obj.Rotate);
writer.WriteOptionalAttributeString("flipx", obj.FlipX);
writer.WriteOptionalAttributeString("width", obj.Width);
writer.WriteOptionalAttributeString("height", obj.Height);
writer.WriteRequiredAttributeString("refresh", obj.Refresh);
writer.WriteOptionalAttributeString("pixclock", obj.PixClock);
writer.WriteOptionalAttributeString("htotal", obj.HTotal);
writer.WriteOptionalAttributeString("hbend", obj.HBEnd);
writer.WriteOptionalAttributeString("hbstart", obj.HBStart);
writer.WriteOptionalAttributeString("vtotal", obj.VTotal);
writer.WriteOptionalAttributeString("vbend", obj.VBEnd);
writer.WriteOptionalAttributeString("vbstart", obj.VBStart);
writer.WriteEndElement();
}
/// <summary>
/// Write a Driver to an XmlTextWriter
/// </summary>
/// <param name="obj">Driver to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDriver(Driver obj, XmlTextWriter writer)
{
writer.WriteStartElement("driver");
writer.WriteRequiredAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("color", obj.Color);
writer.WriteOptionalAttributeString("sound", obj.Sound);
writer.WriteOptionalAttributeString("palettesize", obj.PaletteSize);
writer.WriteRequiredAttributeString("emulation", obj.Emulation);
writer.WriteRequiredAttributeString("cocktail", obj.Cocktail);
writer.WriteRequiredAttributeString("savestate", obj.SaveState);
writer.WriteOptionalAttributeString("requiresartwork", obj.RequiresArtwork);
writer.WriteOptionalAttributeString("unofficial", obj.Unofficial);
writer.WriteOptionalAttributeString("nosoundhardware", obj.NoSoundHardware);
writer.WriteOptionalAttributeString("incomplete", obj.Incomplete);
writer.WriteEndElement();
}
/// <summary>
/// Write a Extension to an XmlTextWriter
/// </summary>
/// <param name="obj">Extension to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteExtension(Extension obj, XmlTextWriter writer)
{
writer.WriteStartElement("extension");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a Feature to an XmlTextWriter
/// </summary>
/// <param name="obj">Feature to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteFeature(Feature obj, XmlTextWriter writer)
{
writer.WriteStartElement("feature");
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("overall", obj.Overall);
writer.WriteEndElement();
}
/// <summary>
/// Write a GameBase to an XmlTextWriter
/// </summary>
/// <param name="obj">GameBase to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteGameBase(GameBase obj, XmlTextWriter writer)
{
if (obj is Game)
writer.WriteStartElement("game");
else if (obj is Machine)
writer.WriteStartElement("machine");
else
return;
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("sourcefile", obj.SourceFile);
writer.WriteOptionalAttributeString("isbios", obj.IsBios);
writer.WriteOptionalAttributeString("isdevice", obj.IsDevice);
writer.WriteOptionalAttributeString("ismechanical", obj.IsMechanical);
writer.WriteOptionalAttributeString("runnable", obj.Runnable);
writer.WriteOptionalAttributeString("cloneof", obj.CloneOf);
writer.WriteOptionalAttributeString("romof", obj.RomOf);
writer.WriteOptionalAttributeString("sampleof", obj.SampleOf);
writer.WriteRequiredElementString("description", obj.Description);
writer.WriteOptionalElementString("year", obj.Year);
writer.WriteOptionalElementString("manufacturer", obj.Manufacturer);
writer.WriteOptionalElementString("history", obj.History);
if (obj.BiosSet is not null && obj.BiosSet.Length > 0)
{
foreach (var biosSet in obj.BiosSet)
{
WriteBiosSet(biosSet, writer);
}
}
if (obj.Rom is not null && obj.Rom.Length > 0)
{
foreach (var rom in obj.Rom)
{
WriteRom(rom, writer);
}
}
if (obj.Disk is not null && obj.Disk.Length > 0)
{
foreach (var disk in obj.Disk)
{
WriteDisk(disk, writer);
}
}
if (obj.DeviceRef is not null && obj.DeviceRef.Length > 0)
{
foreach (var deviceRef in obj.DeviceRef)
{
WriteDeviceRef(deviceRef, writer);
}
}
if (obj.Sample is not null && obj.Sample.Length > 0)
{
foreach (var sample in obj.Sample)
{
WriteSample(sample, writer);
}
}
if (obj.Chip is not null && obj.Chip.Length > 0)
{
foreach (var chip in obj.Chip)
{
WriteChip(chip, writer);
}
}
if (obj.Display is not null && obj.Display.Length > 0)
{
foreach (var display in obj.Display)
{
WriteDisplay(display, writer);
}
}
if (obj.Video is not null && obj.Video.Length > 0)
{
foreach (var video in obj.Video)
{
WriteVideo(video, writer);
}
}
if (obj.Sound is not null)
WriteSound(obj.Sound, writer);
if (obj.Input is not null)
WriteInput(obj.Input, writer);
if (obj.DipSwitch is not null && obj.DipSwitch.Length > 0)
{
foreach (var dipSwitch in obj.DipSwitch)
{
WriteDipSwitch(dipSwitch, writer);
}
}
if (obj.Configuration is not null && obj.Configuration.Length > 0)
{
foreach (var configuration in obj.Configuration)
{
WriteConfiguration(configuration, writer);
}
}
if (obj.Port is not null && obj.Port.Length > 0)
{
foreach (var port in obj.Port)
{
WritePort(port, writer);
}
}
if (obj.Adjuster is not null && obj.Adjuster.Length > 0)
{
foreach (var adjuster in obj.Adjuster)
{
WriteAdjuster(adjuster, writer);
}
}
if (obj.Driver is not null)
WriteDriver(obj.Driver, writer);
if (obj.Feature is not null && obj.Feature.Length > 0)
{
foreach (var feature in obj.Feature)
{
WriteFeature(feature, writer);
}
}
if (obj.Device is not null && obj.Device.Length > 0)
{
foreach (var device in obj.Device)
{
WriteDevice(device, writer);
}
}
if (obj.Slot is not null && obj.Slot.Length > 0)
{
foreach (var slot in obj.Slot)
{
WriteSlot(slot, writer);
}
}
if (obj.SoftwareList is not null && obj.SoftwareList.Length > 0)
{
foreach (var softwareList in obj.SoftwareList)
{
WriteSoftwareList(softwareList, writer);
}
}
if (obj.RamOption is not null && obj.RamOption.Length > 0)
{
foreach (var ramOption in obj.RamOption)
{
WriteRamOption(ramOption, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Input to an XmlTextWriter
/// </summary>
/// <param name="obj">Input to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteInput(Input obj, XmlTextWriter writer)
{
writer.WriteStartElement("input");
writer.WriteOptionalAttributeString("service", obj.Service);
writer.WriteOptionalAttributeString("tilt", obj.Tilt);
writer.WriteRequiredAttributeString("players", obj.Players);
writer.WriteOptionalAttributeString("control", obj.ControlAttr);
writer.WriteOptionalAttributeString("buttons", obj.Buttons);
writer.WriteOptionalAttributeString("coins", obj.Coins);
if (obj.Control is not null && obj.Control.Length > 0)
{
foreach (var control in obj.Control)
{
WriteControl(control, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Instance to an XmlTextWriter
/// </summary>
/// <param name="obj">Instance to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteInstance(Instance obj, XmlTextWriter writer)
{
writer.WriteStartElement("instance");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("briefname", obj.BriefName);
writer.WriteEndElement();
}
/// <summary>
/// Write a Port to an XmlTextWriter
/// </summary>
/// <param name="obj">Port to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WritePort(Port obj, XmlTextWriter writer)
{
writer.WriteStartElement("port");
writer.WriteRequiredAttributeString("tag", obj.Tag);
if (obj.Analog is not null && obj.Analog.Length > 0)
{
foreach (var analog in obj.Analog)
{
WriteAnalog(analog, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a RamOption to an XmlTextWriter
/// </summary>
/// <param name="obj">RamOption to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRamOption(RamOption obj, XmlTextWriter writer)
{
writer.WriteStartElement("ramoption");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Content is not null)
writer.WriteValue(obj.Content);
writer.WriteEndElement();
}
/// <summary>
/// Write a Rom to an XmlTextWriter
/// </summary>
/// <param name="obj">Rom to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRom(Rom obj, XmlTextWriter writer)
{
writer.WriteStartElement("rom");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("bios", obj.Bios);
writer.WriteRequiredAttributeString("size", obj.Size);
writer.WriteOptionalAttributeString("crc", obj.CRC);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("merge", obj.Merge);
writer.WriteOptionalAttributeString("region", obj.Region);
writer.WriteOptionalAttributeString("offset", obj.Offset);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("optional", obj.Optional);
writer.WriteOptionalAttributeString("dispose", obj.Dispose);
writer.WriteOptionalAttributeString("soundonly", obj.SoundOnly);
writer.WriteEndElement();
}
/// <summary>
/// Write a Sample to an XmlTextWriter
/// </summary>
/// <param name="obj">Sample to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSample(Sample obj, XmlTextWriter writer)
{
writer.WriteStartElement("sample");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a Slot to an XmlTextWriter
/// </summary>
/// <param name="obj">Slot to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSlot(Slot obj, XmlTextWriter writer)
{
writer.WriteStartElement("slot");
writer.WriteRequiredAttributeString("name", obj.Name);
if (obj.SlotOption is not null && obj.SlotOption.Length > 0)
{
foreach (var slotOption in obj.SlotOption)
{
WriteSlotOption(slotOption, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a SlotOption to an XmlTextWriter
/// </summary>
/// <param name="obj">SlotOption to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSlotOption(SlotOption obj, XmlTextWriter writer)
{
writer.WriteStartElement("slotoption");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("devname", obj.DevName);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteEndElement();
}
/// <summary>
/// Write a SoftwareList to an XmlTextWriter
/// </summary>
/// <param name="obj">SoftwareList to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSoftwareList(Data.Models.Listxml.SoftwareList obj, XmlTextWriter writer)
{
writer.WriteStartElement("softwarelist");
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("filter", obj.Filter);
writer.WriteEndElement();
}
/// <summary>
/// Write a Sound to an XmlTextWriter
/// </summary>
/// <param name="obj">Sound to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSound(Sound obj, XmlTextWriter writer)
{
writer.WriteStartElement("sound");
writer.WriteRequiredAttributeString("channels", obj.Channels);
writer.WriteEndElement();
}
/// <summary>
/// Write a Video to an XmlTextWriter
/// </summary>
/// <param name="obj">Video to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteVideo(Video obj, XmlTextWriter writer)
{
writer.WriteStartElement("video");
writer.WriteRequiredAttributeString("screen", obj.Screen);
writer.WriteRequiredAttributeString("orientation", obj.Orientation);
writer.WriteOptionalAttributeString("width", obj.Width);
writer.WriteOptionalAttributeString("height", obj.Height);
writer.WriteOptionalAttributeString("aspectx", obj.AspectX);
writer.WriteOptionalAttributeString("aspecty", obj.AspectY);
writer.WriteRequiredAttributeString("refresh", obj.Refresh);
writer.WriteEndElement();
}
#endregion
}
}

837
SabreTools.Serialization.Writers/Mess.cs
View File

@@ -1,7 +1,840 @@
using System.IO;
using System.Text;
using System.Xml;
using SabreTools.Data.Models.Listxml;
using SabreTools.IO.Extensions;
using SabreTools.Text.Extensions;
namespace SabreTools.Serialization.Writers
{
public class Mess : XmlFile<Data.Models.Listxml.Mess>
public class Mess : BaseBinaryWriter<Data.Models.Listxml.Mess>
{
// All logic taken care of in the base class
/// <inheritdoc/>
public override Stream? SerializeStream(Data.Models.Listxml.Mess? obj)
{
// If the metadata file is null
if (obj is null)
return null;
// Setup the writer and output
var stream = new MemoryStream();
var writer = new XmlTextWriter(stream, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
// Write the Mess, if it exists
WriteMess(obj, writer);
writer.Flush();
// Return the stream
stream.SeekIfPossible(0, SeekOrigin.Begin);
return stream;
}
/// <summary>
/// Write a Mess to an XmlTextWriter
/// </summary>
/// <param name="obj">Mess to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteMess(Data.Models.Listxml.Mess obj, XmlTextWriter writer)
{
writer.WriteStartElement("mess");
writer.WriteOptionalAttributeString("version", obj.Version);
if (obj.Game is not null && obj.Game.Length > 0)
{
foreach (var gameBase in obj.Game)
{
WriteGameBase(gameBase, writer);
}
}
writer.WriteEndElement();
}
#region Items
/// <summary>
/// Write a Adjuster to an XmlTextWriter
/// </summary>
/// <param name="obj">Adjuster to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteAdjuster(Adjuster obj, XmlTextWriter writer)
{
writer.WriteStartElement("adjuster");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Analog to an XmlTextWriter
/// </summary>
/// <param name="obj">Analog to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteAnalog(Analog obj, XmlTextWriter writer)
{
writer.WriteStartElement("analog");
writer.WriteRequiredAttributeString("mask", obj.Mask);
writer.WriteEndElement();
}
/// <summary>
/// Write a BiosSet to an XmlTextWriter
/// </summary>
/// <param name="obj">BiosSet to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteBiosSet(BiosSet obj, XmlTextWriter writer)
{
writer.WriteStartElement("biosset");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("description", obj.Description);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteEndElement();
}
/// <summary>
/// Write a Chip to an XmlTextWriter
/// </summary>
/// <param name="obj">Chip to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteChip(Chip obj, XmlTextWriter writer)
{
writer.WriteStartElement("chip");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("soundonly", obj.SoundOnly);
writer.WriteOptionalAttributeString("clock", obj.Clock);
writer.WriteEndElement();
}
/// <summary>
/// Write a Condition to an XmlTextWriter
/// </summary>
/// <param name="obj">Condition to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteCondition(Condition obj, XmlTextWriter writer)
{
writer.WriteStartElement("condition");
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("mask", obj.Mask);
writer.WriteRequiredAttributeString("relation", obj.Relation);
writer.WriteRequiredAttributeString("value", obj.Value);
writer.WriteEndElement();
}
/// <summary>
/// Write a Configuration to an XmlTextWriter
/// </summary>
/// <param name="obj">Configuration to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteConfiguration(Configuration obj, XmlTextWriter writer)
{
writer.WriteStartElement("configuration");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteOptionalAttributeString("mask", obj.Mask);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
if (obj.ConfLocation is not null && obj.ConfLocation.Length > 0)
{
foreach (var confLocation in obj.ConfLocation)
{
WriteConfLocation(confLocation, writer);
}
}
if (obj.ConfSetting is not null && obj.ConfSetting.Length > 0)
{
foreach (var confSetting in obj.ConfSetting)
{
WriteConfSetting(confSetting, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a ConfLocation to an XmlTextWriter
/// </summary>
/// <param name="obj">ConfLocation to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteConfLocation(ConfLocation obj, XmlTextWriter writer)
{
writer.WriteStartElement("conflocation");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("number", obj.Number);
writer.WriteOptionalAttributeString("inverted", obj.Inverted);
writer.WriteEndElement();
}
/// <summary>
/// Write a ConfSetting to an XmlTextWriter
/// </summary>
/// <param name="obj">ConfSetting to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteConfSetting(ConfSetting obj, XmlTextWriter writer)
{
writer.WriteStartElement("confsetting");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("value", obj.Value);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Control to an XmlTextWriter
/// </summary>
/// <param name="obj">Control to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteControl(Control obj, XmlTextWriter writer)
{
writer.WriteStartElement("control");
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("player", obj.Player);
writer.WriteOptionalAttributeString("buttons", obj.Buttons);
writer.WriteOptionalAttributeString("reqbuttons", obj.ReqButtons);
writer.WriteOptionalAttributeString("minimum", obj.Minimum);
writer.WriteOptionalAttributeString("maximum", obj.Maximum);
writer.WriteOptionalAttributeString("sensitivity", obj.Sensitivity);
writer.WriteOptionalAttributeString("keydelta", obj.KeyDelta);
writer.WriteOptionalAttributeString("reverse", obj.Reverse);
writer.WriteOptionalAttributeString("ways", obj.Ways);
writer.WriteOptionalAttributeString("ways2", obj.Ways2);
writer.WriteOptionalAttributeString("ways3", obj.Ways3);
writer.WriteEndElement();
}
/// <summary>
/// Write a Device to an XmlTextWriter
/// </summary>
/// <param name="obj">Device to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDevice(Device obj, XmlTextWriter writer)
{
writer.WriteStartElement("device");
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("tag", obj.Tag);
writer.WriteOptionalAttributeString("fixed_image", obj.FixedImage);
writer.WriteOptionalAttributeString("mandatory", obj.Mandatory);
writer.WriteOptionalAttributeString("interface", obj.Interface);
if (obj.Instance is not null)
WriteInstance(obj.Instance, writer);
if (obj.Extension is not null && obj.Extension.Length > 0)
{
foreach (var extension in obj.Extension)
{
WriteExtension(extension, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a DeviceRef to an XmlTextWriter
/// </summary>
/// <param name="obj">DeviceRef to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDeviceRef(DeviceRef obj, XmlTextWriter writer)
{
writer.WriteStartElement("device_ref");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a DipLocation to an XmlTextWriter
/// </summary>
/// <param name="obj">DipLocation to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipLocation(DipLocation obj, XmlTextWriter writer)
{
writer.WriteStartElement("diplocation");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("number", obj.Number);
writer.WriteOptionalAttributeString("inverted", obj.Inverted);
writer.WriteEndElement();
}
/// <summary>
/// Write a DipSwitch to an XmlTextWriter
/// </summary>
/// <param name="obj">DipSwitch to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipSwitch(DipSwitch obj, XmlTextWriter writer)
{
writer.WriteStartElement("dipswitch");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteOptionalAttributeString("mask", obj.Mask);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
if (obj.DipLocation is not null && obj.DipLocation.Length > 0)
{
foreach (var dipLocation in obj.DipLocation)
{
WriteDipLocation(dipLocation, writer);
}
}
if (obj.DipValue is not null && obj.DipValue.Length > 0)
{
foreach (var dipValue in obj.DipValue)
{
WriteDipValue(dipValue, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a DipValue to an XmlTextWriter
/// </summary>
/// <param name="obj">DipValue to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipValue(DipValue obj, XmlTextWriter writer)
{
writer.WriteStartElement("dipvalue");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("value", obj.Value);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Condition is not null)
WriteCondition(obj.Condition, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Disk to an XmlTextWriter
/// </summary>
/// <param name="obj">Disk to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDisk(Disk obj, XmlTextWriter writer)
{
writer.WriteStartElement("disk");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("md5", obj.MD5);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("merge", obj.Merge);
writer.WriteOptionalAttributeString("region", obj.Region);
writer.WriteOptionalAttributeString("index", obj.Index);
writer.WriteOptionalAttributeString("writable", obj.Writable);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("optional", obj.Optional);
writer.WriteEndElement();
}
/// <summary>
/// Write a Display to an XmlTextWriter
/// </summary>
/// <param name="obj">Display to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDisplay(Display obj, XmlTextWriter writer)
{
writer.WriteStartElement("display");
writer.WriteOptionalAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("rotate", obj.Rotate);
writer.WriteOptionalAttributeString("flipx", obj.FlipX);
writer.WriteOptionalAttributeString("width", obj.Width);
writer.WriteOptionalAttributeString("height", obj.Height);
writer.WriteRequiredAttributeString("refresh", obj.Refresh);
writer.WriteOptionalAttributeString("pixclock", obj.PixClock);
writer.WriteOptionalAttributeString("htotal", obj.HTotal);
writer.WriteOptionalAttributeString("hbend", obj.HBEnd);
writer.WriteOptionalAttributeString("hbstart", obj.HBStart);
writer.WriteOptionalAttributeString("vtotal", obj.VTotal);
writer.WriteOptionalAttributeString("vbend", obj.VBEnd);
writer.WriteOptionalAttributeString("vbstart", obj.VBStart);
writer.WriteEndElement();
}
/// <summary>
/// Write a Driver to an XmlTextWriter
/// </summary>
/// <param name="obj">Driver to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDriver(Driver obj, XmlTextWriter writer)
{
writer.WriteStartElement("driver");
writer.WriteRequiredAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("color", obj.Color);
writer.WriteOptionalAttributeString("sound", obj.Sound);
writer.WriteOptionalAttributeString("palettesize", obj.PaletteSize);
writer.WriteRequiredAttributeString("emulation", obj.Emulation);
writer.WriteRequiredAttributeString("cocktail", obj.Cocktail);
writer.WriteRequiredAttributeString("savestate", obj.SaveState);
writer.WriteOptionalAttributeString("requiresartwork", obj.RequiresArtwork);
writer.WriteOptionalAttributeString("unofficial", obj.Unofficial);
writer.WriteOptionalAttributeString("nosoundhardware", obj.NoSoundHardware);
writer.WriteOptionalAttributeString("incomplete", obj.Incomplete);
writer.WriteEndElement();
}
/// <summary>
/// Write a Extension to an XmlTextWriter
/// </summary>
/// <param name="obj">Extension to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteExtension(Extension obj, XmlTextWriter writer)
{
writer.WriteStartElement("extension");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a Feature to an XmlTextWriter
/// </summary>
/// <param name="obj">Feature to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteFeature(Feature obj, XmlTextWriter writer)
{
writer.WriteStartElement("feature");
writer.WriteRequiredAttributeString("type", obj.Type);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("overall", obj.Overall);
writer.WriteEndElement();
}
/// <summary>
/// Write a GameBase to an XmlTextWriter
/// </summary>
/// <param name="obj">GameBase to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteGameBase(GameBase obj, XmlTextWriter writer)
{
if (obj is Game)
writer.WriteStartElement("game");
else if (obj is Machine)
writer.WriteStartElement("machine");
else
return;
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("sourcefile", obj.SourceFile);
writer.WriteOptionalAttributeString("isbios", obj.IsBios);
writer.WriteOptionalAttributeString("isdevice", obj.IsDevice);
writer.WriteOptionalAttributeString("ismechanical", obj.IsMechanical);
writer.WriteOptionalAttributeString("runnable", obj.Runnable);
writer.WriteOptionalAttributeString("cloneof", obj.CloneOf);
writer.WriteOptionalAttributeString("romof", obj.RomOf);
writer.WriteOptionalAttributeString("sampleof", obj.SampleOf);
writer.WriteRequiredElementString("description", obj.Description);
writer.WriteOptionalElementString("year", obj.Year);
writer.WriteOptionalElementString("manufacturer", obj.Manufacturer);
writer.WriteOptionalElementString("history", obj.History);
if (obj.BiosSet is not null && obj.BiosSet.Length > 0)
{
foreach (var biosSet in obj.BiosSet)
{
WriteBiosSet(biosSet, writer);
}
}
if (obj.Rom is not null && obj.Rom.Length > 0)
{
foreach (var rom in obj.Rom)
{
WriteRom(rom, writer);
}
}
if (obj.Disk is not null && obj.Disk.Length > 0)
{
foreach (var disk in obj.Disk)
{
WriteDisk(disk, writer);
}
}
if (obj.DeviceRef is not null && obj.DeviceRef.Length > 0)
{
foreach (var deviceRef in obj.DeviceRef)
{
WriteDeviceRef(deviceRef, writer);
}
}
if (obj.Sample is not null && obj.Sample.Length > 0)
{
foreach (var sample in obj.Sample)
{
WriteSample(sample, writer);
}
}
if (obj.Chip is not null && obj.Chip.Length > 0)
{
foreach (var chip in obj.Chip)
{
WriteChip(chip, writer);
}
}
if (obj.Display is not null && obj.Display.Length > 0)
{
foreach (var display in obj.Display)
{
WriteDisplay(display, writer);
}
}
if (obj.Video is not null && obj.Video.Length > 0)
{
foreach (var video in obj.Video)
{
WriteVideo(video, writer);
}
}
if (obj.Sound is not null)
WriteSound(obj.Sound, writer);
if (obj.Input is not null)
WriteInput(obj.Input, writer);
if (obj.DipSwitch is not null && obj.DipSwitch.Length > 0)
{
foreach (var dipSwitch in obj.DipSwitch)
{
WriteDipSwitch(dipSwitch, writer);
}
}
if (obj.Configuration is not null && obj.Configuration.Length > 0)
{
foreach (var configuration in obj.Configuration)
{
WriteConfiguration(configuration, writer);
}
}
if (obj.Port is not null && obj.Port.Length > 0)
{
foreach (var port in obj.Port)
{
WritePort(port, writer);
}
}
if (obj.Adjuster is not null && obj.Adjuster.Length > 0)
{
foreach (var adjuster in obj.Adjuster)
{
WriteAdjuster(adjuster, writer);
}
}
if (obj.Driver is not null)
WriteDriver(obj.Driver, writer);
if (obj.Feature is not null && obj.Feature.Length > 0)
{
foreach (var feature in obj.Feature)
{
WriteFeature(feature, writer);
}
}
if (obj.Device is not null && obj.Device.Length > 0)
{
foreach (var device in obj.Device)
{
WriteDevice(device, writer);
}
}
if (obj.Slot is not null && obj.Slot.Length > 0)
{
foreach (var slot in obj.Slot)
{
WriteSlot(slot, writer);
}
}
if (obj.SoftwareList is not null && obj.SoftwareList.Length > 0)
{
foreach (var softwareList in obj.SoftwareList)
{
WriteSoftwareList(softwareList, writer);
}
}
if (obj.RamOption is not null && obj.RamOption.Length > 0)
{
foreach (var ramOption in obj.RamOption)
{
WriteRamOption(ramOption, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Input to an XmlTextWriter
/// </summary>
/// <param name="obj">Input to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteInput(Input obj, XmlTextWriter writer)
{
writer.WriteStartElement("input");
writer.WriteOptionalAttributeString("service", obj.Service);
writer.WriteOptionalAttributeString("tilt", obj.Tilt);
writer.WriteRequiredAttributeString("players", obj.Players);
writer.WriteOptionalAttributeString("control", obj.ControlAttr);
writer.WriteOptionalAttributeString("buttons", obj.Buttons);
writer.WriteOptionalAttributeString("coins", obj.Coins);
if (obj.Control is not null && obj.Control.Length > 0)
{
foreach (var control in obj.Control)
{
WriteControl(control, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Instance to an XmlTextWriter
/// </summary>
/// <param name="obj">Instance to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteInstance(Instance obj, XmlTextWriter writer)
{
writer.WriteStartElement("instance");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("briefname", obj.BriefName);
writer.WriteEndElement();
}
/// <summary>
/// Write a Port to an XmlTextWriter
/// </summary>
/// <param name="obj">Port to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WritePort(Port obj, XmlTextWriter writer)
{
writer.WriteStartElement("port");
writer.WriteRequiredAttributeString("tag", obj.Tag);
if (obj.Analog is not null && obj.Analog.Length > 0)
{
foreach (var analog in obj.Analog)
{
WriteAnalog(analog, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a RamOption to an XmlTextWriter
/// </summary>
/// <param name="obj">RamOption to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRamOption(RamOption obj, XmlTextWriter writer)
{
writer.WriteStartElement("ramoption");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("default", obj.Default);
if (obj.Content is not null)
writer.WriteValue(obj.Content);
writer.WriteEndElement();
}
/// <summary>
/// Write a Rom to an XmlTextWriter
/// </summary>
/// <param name="obj">Rom to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRom(Rom obj, XmlTextWriter writer)
{
writer.WriteStartElement("rom");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("bios", obj.Bios);
writer.WriteRequiredAttributeString("size", obj.Size);
writer.WriteOptionalAttributeString("crc", obj.CRC);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("merge", obj.Merge);
writer.WriteOptionalAttributeString("region", obj.Region);
writer.WriteOptionalAttributeString("offset", obj.Offset);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("optional", obj.Optional);
writer.WriteOptionalAttributeString("dispose", obj.Dispose);
writer.WriteOptionalAttributeString("soundonly", obj.SoundOnly);
writer.WriteEndElement();
}
/// <summary>
/// Write a Sample to an XmlTextWriter
/// </summary>
/// <param name="obj">Sample to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSample(Sample obj, XmlTextWriter writer)
{
writer.WriteStartElement("sample");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteEndElement();
}
/// <summary>
/// Write a Slot to an XmlTextWriter
/// </summary>
/// <param name="obj">Slot to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSlot(Slot obj, XmlTextWriter writer)
{
writer.WriteStartElement("slot");
writer.WriteRequiredAttributeString("name", obj.Name);
if (obj.SlotOption is not null && obj.SlotOption.Length > 0)
{
foreach (var slotOption in obj.SlotOption)
{
WriteSlotOption(slotOption, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a SlotOption to an XmlTextWriter
/// </summary>
/// <param name="obj">SlotOption to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSlotOption(SlotOption obj, XmlTextWriter writer)
{
writer.WriteStartElement("slotoption");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("devname", obj.DevName);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteEndElement();
}
/// <summary>
/// Write a SoftwareList to an XmlTextWriter
/// </summary>
/// <param name="obj">SoftwareList to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSoftwareList(Data.Models.Listxml.SoftwareList obj, XmlTextWriter writer)
{
writer.WriteStartElement("softwarelist");
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("filter", obj.Filter);
writer.WriteEndElement();
}
/// <summary>
/// Write a Sound to an XmlTextWriter
/// </summary>
/// <param name="obj">Sound to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSound(Sound obj, XmlTextWriter writer)
{
writer.WriteStartElement("sound");
writer.WriteRequiredAttributeString("channels", obj.Channels);
writer.WriteEndElement();
}
/// <summary>
/// Write a Video to an XmlTextWriter
/// </summary>
/// <param name="obj">Video to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteVideo(Video obj, XmlTextWriter writer)
{
writer.WriteStartElement("video");
writer.WriteRequiredAttributeString("screen", obj.Screen);
writer.WriteRequiredAttributeString("orientation", obj.Orientation);
writer.WriteOptionalAttributeString("width", obj.Width);
writer.WriteOptionalAttributeString("height", obj.Height);
writer.WriteOptionalAttributeString("aspectx", obj.AspectX);
writer.WriteOptionalAttributeString("aspecty", obj.AspectY);
writer.WriteRequiredAttributeString("refresh", obj.Refresh);
writer.WriteEndElement();
}
#endregion
}
}

444
SabreTools.Serialization.Writers/OfflineList.cs
View File

@@ -1,9 +1,449 @@
using System.IO;
using System.Text;
using System.Xml;
using SabreTools.Data.Models.OfflineList;
using SabreTools.IO.Extensions;
using SabreTools.Text.Extensions;
namespace SabreTools.Serialization.Writers
{
public class OfflineList : XmlFile<Dat>
public class OfflineList : BaseBinaryWriter<Dat>
{
// All logic taken care of in the base class
/// <inheritdoc/>
public override Stream? SerializeStream(Dat? obj)
{
// If the metadata file is null
if (obj is null)
return null;
// Setup the writer and output
var stream = new MemoryStream();
var writer = new XmlTextWriter(stream, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
// Write the Dat, if it exists
WriteDat(obj, writer);
writer.Flush();
// Return the stream
stream.SeekIfPossible(0, SeekOrigin.Begin);
return stream;
}
/// <summary>
/// Write a Dat to an XmlTextWriter
/// </summary>
/// <param name="obj">Dat to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDat(Dat obj, XmlTextWriter writer)
{
writer.WriteStartElement("dat");
// TODO: Fix this schema reading/writing
// writer.WriteOptionalAttributeString("noNamespaceSchemaLocation", obj.NoNamespaceSchemaLocation);
if (obj.Configuration is not null)
WriteConfiguration(obj.Configuration, writer);
if (obj.Games is not null)
WriteGames(obj.Games, writer);
if (obj.GUI is not null)
WriteGUI(obj.GUI, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a CanOpen to an XmlTextWriter
/// </summary>
/// <param name="obj">CanOpen to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteCanOpen(CanOpen obj, XmlTextWriter writer)
{
writer.WriteStartElement("canOpen");
if (obj.Extension is not null && obj.Extension.Length > 0)
{
foreach (var extension in obj.Extension)
{
writer.WriteOptionalElementString("extension", extension);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Configuration to an XmlTextWriter
/// </summary>
/// <param name="obj">Configuration to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteConfiguration(Configuration obj, XmlTextWriter writer)
{
writer.WriteStartElement("configuration");
writer.WriteOptionalElementString("datName", obj.DatName);
writer.WriteOptionalElementString("imFolder", obj.ImFolder);
writer.WriteOptionalElementString("datVersion", obj.DatVersion);
writer.WriteOptionalElementString("system", obj.System);
writer.WriteOptionalElementString("screenshotsWidth", obj.ScreenshotsWidth);
writer.WriteOptionalElementString("screenshotsHeight", obj.ScreenshotsHeight);
if (obj.Infos is not null)
WriteInfos(obj.Infos, writer);
if (obj.CanOpen is not null)
WriteCanOpen(obj.CanOpen, writer);
if (obj.NewDat is not null)
WriteNewDat(obj.NewDat, writer);
if (obj.Search is not null)
WriteSearch(obj.Search, writer);
writer.WriteOptionalElementString("romTitle", obj.RomTitle);
writer.WriteEndElement();
}
/// <summary>
/// Write a DatUrl to an XmlTextWriter
/// </summary>
/// <param name="obj">DatUrl to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDatUrl(DatUrl obj, XmlTextWriter writer)
{
writer.WriteStartElement("datURL");
writer.WriteOptionalAttributeString("fileName", obj.FileName);
if (obj.Content is not null)
writer.WriteRaw(obj.Content);
writer.WriteEndElement();
}
/// <summary>
/// Write a FileRomCRC to an XmlTextWriter
/// </summary>
/// <param name="obj">FileRomCRC to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteFileRomCRC(FileRomCRC obj, XmlTextWriter writer)
{
writer.WriteStartElement("romCRC");
writer.WriteOptionalAttributeString("extension", obj.Extension);
if (obj.Content is not null)
writer.WriteRaw(obj.Content);
writer.WriteEndElement();
}
/// <summary>
/// Write a Files to an XmlTextWriter
/// </summary>
/// <param name="obj">Files to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteFiles(Files obj, XmlTextWriter writer)
{
writer.WriteStartElement("files");
if (obj.RomCRC is not null && obj.RomCRC.Length > 0)
{
foreach (var extension in obj.RomCRC)
{
WriteFileRomCRC(extension, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Find to an XmlTextWriter
/// </summary>
/// <param name="obj">Find to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteFind(Find obj, XmlTextWriter writer)
{
writer.WriteStartElement("find");
writer.WriteOptionalAttributeString("operation", obj.Operation);
writer.WriteOptionalAttributeString("value", obj.Value);
if (obj.Content is not null)
writer.WriteRaw(obj.Content);
writer.WriteEndElement();
}
/// <summary>
/// Write a Game to an XmlTextWriter
/// </summary>
/// <param name="obj">Game to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteGame(Game obj, XmlTextWriter writer)
{
writer.WriteStartElement("game");
writer.WriteOptionalElementString("imageNumber", obj.ImageNumber);
writer.WriteOptionalElementString("releaseNumber", obj.ReleaseNumber);
writer.WriteOptionalElementString("title", obj.Title);
writer.WriteOptionalElementString("saveType", obj.SaveType);
writer.WriteOptionalElementString("romSize", obj.RomSize);
writer.WriteOptionalElementString("publisher", obj.Publisher);
writer.WriteOptionalElementString("location", obj.Location);
writer.WriteOptionalElementString("sourceRom", obj.SourceRom);
writer.WriteOptionalElementString("language", obj.Language);
if (obj.Files is not null)
WriteFiles(obj.Files, writer);
writer.WriteOptionalElementString("im1CRC", obj.Im1CRC);
writer.WriteOptionalElementString("im2CRC", obj.Im2CRC);
writer.WriteOptionalElementString("comment", obj.Comment);
writer.WriteOptionalElementString("duplicateID", obj.DuplicateID);
writer.WriteEndElement();
}
/// <summary>
/// Write a Games to an XmlTextWriter
/// </summary>
/// <param name="obj">Games to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteGames(Games obj, XmlTextWriter writer)
{
writer.WriteStartElement("games");
if (obj.Game is not null && obj.Game.Length > 0)
{
foreach (var game in obj.Game)
{
WriteGame(game, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a GUI to an XmlTextWriter
/// </summary>
/// <param name="obj">GUI to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteGUI(GUI obj, XmlTextWriter writer)
{
writer.WriteStartElement("gui");
if (obj.Images is not null)
WriteImages(obj.Images, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Image to an XmlTextWriter
/// </summary>
/// <param name="obj">Image to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteImage(Image obj, XmlTextWriter writer)
{
writer.WriteStartElement("image");
writer.WriteOptionalAttributeString("x", obj.X);
writer.WriteOptionalAttributeString("y", obj.Y);
writer.WriteOptionalAttributeString("width", obj.Width);
writer.WriteOptionalAttributeString("height", obj.Height);
writer.WriteEndElement();
}
/// <summary>
/// Write a Images to an XmlTextWriter
/// </summary>
/// <param name="obj">Images to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteImages(Images obj, XmlTextWriter writer)
{
writer.WriteStartElement("images");
writer.WriteOptionalAttributeString("width", obj.Width);
writer.WriteOptionalAttributeString("height", obj.Height);
if (obj.Image is not null && obj.Image.Length > 0)
{
foreach (var image in obj.Image)
{
WriteImage(image, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a InfoBase to an XmlTextWriter
/// </summary>
/// <param name="obj">InfoBase to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteInfoBase(InfoBase obj, XmlTextWriter writer)
{
if (obj is Title)
writer.WriteStartElement("title");
else if (obj is Location)
writer.WriteStartElement("location");
else if (obj is Publisher)
writer.WriteStartElement("publisher");
else if (obj is SourceRom)
writer.WriteStartElement("sourceRom");
else if (obj is SaveType)
writer.WriteStartElement("saveType");
else if (obj is RomSize)
writer.WriteStartElement("romSize");
else if (obj is ReleaseNumber)
writer.WriteStartElement("releaseNumber");
else if (obj is ImageNumber)
writer.WriteStartElement("imageNumber");
else if (obj is LanguageNumber)
writer.WriteStartElement("languageNumber");
else if (obj is Comment)
writer.WriteStartElement("comment");
else if (obj is RomCRC)
writer.WriteStartElement("romCRC");
else if (obj is Im1CRC)
writer.WriteStartElement("im1CRC");
else if (obj is Im2CRC)
writer.WriteStartElement("im2CRC");
else if (obj is Languages)
writer.WriteStartElement("languages");
else
return;
writer.WriteOptionalAttributeString("visible", obj.Visible);
writer.WriteOptionalAttributeString("inNamingOption", obj.InNamingOption);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteEndElement();
}
/// <summary>
/// Write a Infos to an XmlTextWriter
/// </summary>
/// <param name="obj">Infos to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteInfos(Infos obj, XmlTextWriter writer)
{
writer.WriteStartElement("infos");
if (obj.Title is not null)
WriteInfoBase(obj.Title, writer);
if (obj.Location is not null)
WriteInfoBase(obj.Location, writer);
if (obj.Publisher is not null)
WriteInfoBase(obj.Publisher, writer);
if (obj.SourceRom is not null)
WriteInfoBase(obj.SourceRom, writer);
if (obj.SaveType is not null)
WriteInfoBase(obj.SaveType, writer);
if (obj.RomSize is not null)
WriteInfoBase(obj.RomSize, writer);
if (obj.ReleaseNumber is not null)
WriteInfoBase(obj.ReleaseNumber, writer);
if (obj.ImageNumber is not null)
WriteInfoBase(obj.ImageNumber, writer);
if (obj.LanguageNumber is not null)
WriteInfoBase(obj.LanguageNumber, writer);
if (obj.Comment is not null)
WriteInfoBase(obj.Comment, writer);
if (obj.RomCRC is not null)
WriteInfoBase(obj.RomCRC, writer);
if (obj.Im1CRC is not null)
WriteInfoBase(obj.Im1CRC, writer);
if (obj.Im2CRC is not null)
WriteInfoBase(obj.Im2CRC, writer);
if (obj.Languages is not null)
WriteInfoBase(obj.Languages, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a NewDat to an XmlTextWriter
/// </summary>
/// <param name="obj">NewDat to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteNewDat(NewDat obj, XmlTextWriter writer)
{
writer.WriteStartElement("newDat");
writer.WriteOptionalElementString("datVersionURL", obj.DatVersionUrl);
if (obj.DatUrl is not null)
WriteDatUrl(obj.DatUrl, writer);
writer.WriteOptionalElementString("imURL", obj.ImUrl);
writer.WriteEndElement();
}
/// <summary>
/// Write a Search to an XmlTextWriter
/// </summary>
/// <param name="obj">Search to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSearch(Search obj, XmlTextWriter writer)
{
writer.WriteStartElement("search");
if (obj.To is not null && obj.To.Length > 0)
{
foreach (var to in obj.To)
{
WriteTo(to, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a To to an XmlTextWriter
/// </summary>
/// <param name="obj">To to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteTo(To obj, XmlTextWriter writer)
{
writer.WriteStartElement("to");
writer.WriteOptionalAttributeString("value", obj.Value);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteOptionalAttributeString("auto", obj.Auto);
if (obj.Find is not null && obj.Find.Length > 0)
{
foreach (var find in obj.Find)
{
WriteFind(find, writer);
}
}
writer.WriteEndElement();
}
}
}

156
SabreTools.Serialization.Writers/OpenMSX.cs
View File

@@ -1,9 +1,13 @@
using System.IO;
using System.Text;
using System.Xml;
using SabreTools.Data.Models.OpenMSX;
using SabreTools.IO.Extensions;
using SabreTools.Text.Extensions;
namespace SabreTools.Serialization.Writers
{
public class OpenMSX : XmlFile<SoftwareDb>
public class OpenMSX : BaseBinaryWriter<SoftwareDb>
{
#region Constants
@@ -29,28 +33,136 @@ namespace SabreTools.Serialization.Writers
#endregion
#region IByteWriter
/// <inheritdoc cref="XmlFile.SerializeArray(T?, string?, string?, string?, string?)" />
public override byte[]? SerializeArray(SoftwareDb? obj)
=> SerializeArray(obj, DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSysId);
#endregion
#region IFileWriter
/// <inheritdoc cref="XmlFile.Serialize(T?, string?, string?, string?, string?, string?)" />
public override bool SerializeFile(SoftwareDb? obj, string? path)
=> Serialize(obj, path, DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSysId);
#endregion
#region IStreamWriter
/// <inheritdoc cref="XmlFile.Serialize(T?, string?, string?, string?, string?)" />
/// <inheritdoc/>
public override Stream? SerializeStream(SoftwareDb? obj)
=> Serialize(obj, DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSysId);
{
// If the metadata file is null
if (obj is null)
return null;
#endregion
// Setup the writer and output
var stream = new MemoryStream();
var writer = new XmlTextWriter(stream, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
// Write document type
writer.WriteDocType(DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSubset);
// Write the SoftwareDb, if it exists
WriteSoftwareDb(obj, writer);
writer.Flush();
// Return the stream
stream.SeekIfPossible(0, SeekOrigin.Begin);
return stream;
}
/// <summary>
/// Write a SoftwareDb to an XmlTextWriter
/// </summary>
/// <param name="obj">SoftwareDb to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSoftwareDb(SoftwareDb obj, XmlTextWriter writer)
{
writer.WriteStartElement("softwaredb");
writer.WriteOptionalAttributeString("timestamp", obj.Timestamp);
if (obj.Software is not null && obj.Software.Length > 0)
{
foreach (var software in obj.Software)
{
WriteSoftware(software, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Dump to an XmlTextWriter
/// </summary>
/// <param name="obj">Dump to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDump(Dump obj, XmlTextWriter writer)
{
writer.WriteStartElement("dump");
if (obj.Original is not null)
WriteOriginal(obj.Original, writer);
if (obj.Rom is not null)
WriteRomBase(obj.Rom, writer);
writer.WriteEndElement();
}
/// <summary>
/// Write a Original to an XmlTextWriter
/// </summary>
/// <param name="obj">Original to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteOriginal(Original obj, XmlTextWriter writer)
{
writer.WriteStartElement("original");
writer.WriteOptionalAttributeString("value", obj.Value);
if (obj.Content is not null)
writer.WriteRaw(obj.Content);
writer.WriteEndElement();
}
/// <summary>
/// Write a RomBase to an XmlTextWriter
/// </summary>
/// <param name="obj">RomBase to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRomBase(RomBase obj, XmlTextWriter writer)
{
if (obj is MegaRom)
writer.WriteStartElement("megarom");
else if (obj is Rom)
writer.WriteStartElement("rom");
else if (obj is SCCPlusCart)
writer.WriteStartElement("sccpluscart");
else
return;
writer.WriteOptionalElementString("start", obj.Start);
writer.WriteOptionalElementString("type", obj.Type);
writer.WriteOptionalElementString("hash", obj.Hash);
writer.WriteOptionalElementString("remark", obj.Remark);
writer.WriteEndElement();
}
/// <summary>
/// Write a Software to an XmlTextWriter
/// </summary>
/// <param name="obj">Software to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSoftware(Software obj, XmlTextWriter writer)
{
writer.WriteStartElement("software");
writer.WriteRequiredElementString("title", obj.Title);
writer.WriteOptionalElementString("genmsxid", obj.GenMSXID);
writer.WriteRequiredElementString("system", obj.System);
writer.WriteRequiredElementString("company", obj.Company);
writer.WriteRequiredElementString("year", obj.Year);
writer.WriteRequiredElementString("country", obj.Country);
if (obj.Dump is not null && obj.Dump.Length > 0)
{
foreach (var dump in obj.Dump)
{
WriteDump(dump, writer);
}
}
writer.WriteEndElement();
}
}
}

332
SabreTools.Serialization.Writers/SoftwareList.cs
View File

@@ -1,8 +1,13 @@
using System.IO;
using System.Text;
using System.Xml;
using SabreTools.Data.Models.SoftwareList;
using SabreTools.IO.Extensions;
using SabreTools.Text.Extensions;
namespace SabreTools.Serialization.Writers
{
public class SoftwareList : XmlFile<Data.Models.SoftwareList.SoftwareList>
public class SoftwareList : BaseBinaryWriter<Data.Models.SoftwareList.SoftwareList>
{
#region Constants
@@ -28,19 +33,320 @@ namespace SabreTools.Serialization.Writers
#endregion
#region IFileWriter
/// <inheritdoc cref="XmlFile.Serialize(T?, string?, string?, string?, string?, string?)" />
public override bool SerializeFile(Data.Models.SoftwareList.SoftwareList? obj, string? path)
=> Serialize(obj, path, DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSysId);
#endregion
#region IStreamWriter
/// <inheritdoc cref="XmlFile.Serialize(T?, string?, string?, string?, string?)" />
/// <inheritdoc/>
public override Stream? SerializeStream(Data.Models.SoftwareList.SoftwareList? obj)
=> Serialize(obj, DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSysId);
{
// If the metadata file is null
if (obj is null)
return null;
// Setup the writer and output
var stream = new MemoryStream();
var writer = new XmlTextWriter(stream, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
// Write document type
writer.WriteDocType(DocTypeName, DocTypePubId, DocTypeSysId, DocTypeSubset);
// Write the SoftwareDb, if it exists
WriteSoftwareList(obj, writer);
writer.Flush();
// Return the stream
stream.SeekIfPossible(0, SeekOrigin.Begin);
return stream;
}
/// <summary>
/// Write a SoftwareList to an XmlTextWriter
/// </summary>
/// <param name="obj">SoftwareList to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSoftwareList(Data.Models.SoftwareList.SoftwareList obj, XmlTextWriter writer)
{
writer.WriteStartElement("softwarelist");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("description", obj.Description);
writer.WriteOptionalElementString("notes", obj.Notes);
if (obj.Software is not null && obj.Software.Length > 0)
{
foreach (var software in obj.Software)
{
WriteSoftware(software, writer);
}
}
writer.WriteEndElement();
}
#region Items
/// <summary>
/// Write a DataArea to an XmlTextWriter
/// </summary>
/// <param name="obj">DataArea to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDataArea(DataArea obj, XmlTextWriter writer)
{
writer.WriteStartElement("dataarea");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("size", obj.Size);
writer.WriteOptionalAttributeString("width", obj.Width);
writer.WriteOptionalAttributeString("endianness", obj.Endianness);
if (obj.Rom is not null && obj.Rom.Length > 0)
{
foreach (var rom in obj.Rom)
{
WriteRom(rom, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a DipSwitch to an XmlTextWriter
/// </summary>
/// <param name="obj">DipSwitch to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipSwitch(DipSwitch obj, XmlTextWriter writer)
{
writer.WriteStartElement("dipswitch");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("tag", obj.Tag);
writer.WriteOptionalAttributeString("mask", obj.Mask);
if (obj.DipValue is not null && obj.DipValue.Length > 0)
{
foreach (var dipValue in obj.DipValue)
{
WriteDipValue(dipValue, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a DipValue to an XmlTextWriter
/// </summary>
/// <param name="obj">DipValue to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDipValue(DipValue obj, XmlTextWriter writer)
{
writer.WriteStartElement("dipvalue");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("value", obj.Value);
writer.WriteOptionalAttributeString("default", obj.Default);
writer.WriteEndElement();
}
/// <summary>
/// Write a Disk to an XmlTextWriter
/// </summary>
/// <param name="obj">Disk to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDisk(Disk obj, XmlTextWriter writer)
{
writer.WriteStartElement("disk");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("md5", obj.MD5);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("writable", obj.Writeable);
writer.WriteEndElement();
}
/// <summary>
/// Write a DiskArea to an XmlTextWriter
/// </summary>
/// <param name="obj">DiskArea to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteDiskArea(DiskArea obj, XmlTextWriter writer)
{
writer.WriteStartElement("diskarea");
writer.WriteRequiredAttributeString("name", obj.Name);
if (obj.Disk is not null && obj.Disk.Length > 0)
{
foreach (var disk in obj.Disk)
{
WriteDisk(disk, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Feature to an XmlTextWriter
/// </summary>
/// <param name="obj">Feature to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteFeature(Feature obj, XmlTextWriter writer)
{
writer.WriteStartElement("feature");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("value", obj.Value);
writer.WriteEndElement();
}
/// <summary>
/// Write a Info to an XmlTextWriter
/// </summary>
/// <param name="obj">Info to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteInfo(Info obj, XmlTextWriter writer)
{
writer.WriteStartElement("info");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("value", obj.Value);
writer.WriteEndElement();
}
/// <summary>
/// Write a Part to an XmlTextWriter
/// </summary>
/// <param name="obj">Part to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WritePart(Part obj, XmlTextWriter writer)
{
writer.WriteStartElement("part");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteRequiredAttributeString("interface", obj.Interface);
if (obj.Feature is not null && obj.Feature.Length > 0)
{
foreach (var feature in obj.Feature)
{
WriteFeature(feature, writer);
}
}
if (obj.DataArea is not null && obj.DataArea.Length > 0)
{
foreach (var dataArea in obj.DataArea)
{
WriteDataArea(dataArea, writer);
}
}
if (obj.DiskArea is not null && obj.DiskArea.Length > 0)
{
foreach (var diskArea in obj.DiskArea)
{
WriteDiskArea(diskArea, writer);
}
}
if (obj.DipSwitch is not null && obj.DipSwitch.Length > 0)
{
foreach (var dipSwitch in obj.DipSwitch)
{
WriteDipSwitch(dipSwitch, writer);
}
}
writer.WriteEndElement();
}
/// <summary>
/// Write a Rom to an XmlTextWriter
/// </summary>
/// <param name="obj">Rom to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteRom(Rom obj, XmlTextWriter writer)
{
writer.WriteStartElement("rom");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("size", obj.Size);
writer.WriteOptionalAttributeString("length", obj.Length);
writer.WriteOptionalAttributeString("crc", obj.CRC);
writer.WriteOptionalAttributeString("sha1", obj.SHA1);
writer.WriteOptionalAttributeString("offset", obj.Offset);
writer.WriteOptionalAttributeString("value", obj.Value);
writer.WriteOptionalAttributeString("status", obj.Status);
writer.WriteOptionalAttributeString("loadflag", obj.LoadFlag);
writer.WriteEndElement();
}
/// <summary>
/// Write a SharedFeat to an XmlTextWriter
/// </summary>
/// <param name="obj">SharedFeat to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSharedFeat(SharedFeat obj, XmlTextWriter writer)
{
writer.WriteStartElement("sharedfeat");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("value", obj.Value);
writer.WriteEndElement();
}
/// <summary>
/// Write a Software to an XmlTextWriter
/// </summary>
/// <param name="obj">Software to write</param>
/// <param name="writer">XmlTextReader to write to</param>
private static void WriteSoftware(Software obj, XmlTextWriter writer)
{
writer.WriteStartElement("software");
writer.WriteRequiredAttributeString("name", obj.Name);
writer.WriteOptionalAttributeString("cloneof", obj.CloneOf);
writer.WriteOptionalAttributeString("supported", obj.Supported);
writer.WriteRequiredElementString("description", obj.Description);
writer.WriteRequiredElementString("year", obj.Year);
writer.WriteRequiredElementString("publisher", obj.Publisher);
writer.WriteOptionalElementString("notes", obj.Notes);
if (obj.Info is not null && obj.Info.Length > 0)
{
foreach (var info in obj.Info)
{
WriteInfo(info, writer);
}
}
if (obj.SharedFeat is not null && obj.SharedFeat.Length > 0)
{
foreach (var sharedFeat in obj.SharedFeat)
{
WriteSharedFeat(sharedFeat, writer);
}
}
if (obj.Part is not null && obj.Part.Length > 0)
{
foreach (var part in obj.Part)
{
WritePart(part, writer);
}
}
writer.WriteEndElement();
}
#endregion
}

130
SabreTools.Serialization.Writers/XmlFile.cs
View File

@@ -1,130 +0,0 @@
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using SabreTools.IO.Extensions;
namespace SabreTools.Serialization.Writers
{
/// <summary>
/// Base class for other XML serializers
/// </summary>
/// <typeparam name="T"></typeparam>
public class XmlFile<T> : BaseBinaryWriter<T>
{
#region IByteWriter
/// <inheritdoc/>
public override byte[]? SerializeArray(T? obj)
=> SerializeArray(obj, null, null, null, null);
/// <summary>
/// Serializes the defined type to a byte array
/// </summary>
/// <param name="obj">Data to serialize</param>
/// <param name="name">Optional DOCTYPE name</param>
/// <param name="pubid">Optional DOCTYPE pubid</param>
/// <param name="sysid">Optional DOCTYPE sysid</param>
/// <param name="subset">Optional DOCTYPE name</param>
/// <returns>Byte array containing serialized data on success, null otherwise</returns>
public byte[]? SerializeArray(T? obj, string? name = null, string? pubid = null, string? sysid = null, string? subset = null)
{
using var stream = Serialize(obj, name, pubid, sysid, subset);
if (stream is null)
return null;
byte[] bytes = new byte[stream.Length];
int read = stream.Read(bytes, 0, bytes.Length);
return bytes;
}
#endregion
#region IFileWriter
/// <inheritdoc/>
public override bool SerializeFile(T? obj, string? path)
=> Serialize(obj, path, null, null, null, null);
/// <summary>
/// Serializes the defined type to an XML file
/// </summary>
/// <param name="obj">Data to serialize</param>
/// <param name="path">Path to the file to serialize to</param>
/// <param name="name">Optional DOCTYPE name</param>
/// <param name="pubid">Optional DOCTYPE pubid</param>
/// <param name="sysid">Optional DOCTYPE sysid</param>
/// <param name="subset">Optional DOCTYPE name</param>
/// <returns>True on successful serialization, false otherwise</returns>
public bool Serialize(T? obj, string? path, string? name = null, string? pubid = null, string? sysid = null, string? subset = null)
{
if (string.IsNullOrEmpty(path))
return false;
using var stream = Serialize(obj, name, pubid, sysid, subset);
if (stream is null)
return false;
using var fs = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None);
stream.BlockCopy(fs);
fs.Flush();
return true;
}
#endregion
#region IStreamWriter
/// <inheritdoc/>
public override Stream? SerializeStream(T? obj)
=> Serialize(obj, null, null, null, null);
/// <summary>
/// Serializes the defined type to a stream
/// </summary>
/// <param name="obj">Data to serialize</param>
/// <param name="name">Optional DOCTYPE name</param>
/// <param name="pubid">Optional DOCTYPE pubid</param>
/// <param name="sysid">Optional DOCTYPE sysid</param>
/// <param name="subset">Optional DOCTYPE name</param>
/// <returns>Stream containing serialized data on success, null otherwise</returns>
public Stream? Serialize(T? obj, string? name = null, string? pubid = null, string? sysid = null, string? subset = null)
{
// If the object is null
if (obj is null)
return null;
// Setup the serializer and the writer
var serializer = new XmlSerializer(typeof(T));
var namespaces = new XmlSerializerNamespaces();
namespaces.Add("", "");
var settings = new XmlWriterSettings
{
CheckCharacters = false,
Encoding = Encoding.UTF8,
Indent = true,
IndentChars = "\t",
#if NET40_OR_GREATER || NETCOREAPP || NETSTANDARD2_0_OR_GREATER
NamespaceHandling = NamespaceHandling.OmitDuplicates,
#endif
NewLineChars = "\n",
};
var stream = new MemoryStream();
var streamWriter = new StreamWriter(stream);
var xmlWriter = XmlWriter.Create(streamWriter, settings);
// Write the doctype if provided
if (!string.IsNullOrEmpty(name))
xmlWriter.WriteDocType(name, pubid, sysid, subset);
// Perform the deserialization and return
serializer.Serialize(xmlWriter, obj, namespaces);
stream.SeekIfPossible(0, SeekOrigin.Begin);
return stream;
}
#endregion
}
}