claunia/SabreTools
1
0
Fork 0
mirror of https://github.com/claunia/SabreTools.git synced 2025-12-16 19:14:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Create and use base class for readers/writers

Browse Source
This commit is contained in:
Matt Nadareski
2024-03-12 19:54:43 -04:00
parent 76e3b0d83a
commit 910b87fa73
46 changed files with 1399 additions and 2388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
SabreTools.DatFiles/DatFile.cs
View File

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

29
SabreTools.DatFiles/Formats/ArchiveDotOrg.Reader.cs
View File

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

51
SabreTools.DatFiles/Formats/ArchiveDotOrg.Writer.cs
View File

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

20
SabreTools.DatFiles/Formats/ArchiveDotOrg.cs
View File

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

29
SabreTools.DatFiles/Formats/AttractMode.Reader.cs
View File

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

60
SabreTools.DatFiles/Formats/AttractMode.Writer.cs
View File

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

29
SabreTools.DatFiles/Formats/AttractMode.cs
View File

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

29
SabreTools.DatFiles/Formats/ClrMamePro.Reader.cs
View File

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

161
SabreTools.DatFiles/Formats/ClrMamePro.Writer.cs
View File

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

176
SabreTools.DatFiles/Formats/ClrMamePro.cs
View File

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

29
SabreTools.DatFiles/Formats/DosCenter.Reader.cs
View File

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

73
SabreTools.DatFiles/Formats/DosCenter.Writer.cs
View File

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

44
SabreTools.DatFiles/Formats/DosCenter.cs
View File

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

29
SabreTools.DatFiles/Formats/EverdriveSMDB.Reader.cs
View File

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

77
SabreTools.DatFiles/Formats/EverdriveSMDB.Writer.cs
View File

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

44
SabreTools.DatFiles/Formats/EverdriveSmdb.cs
View File

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

29
SabreTools.DatFiles/Formats/Hashfile.Reader.cs
View File

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

176
SabreTools.DatFiles/Formats/Hashfile.Writer.cs
View File

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

190
SabreTools.DatFiles/Formats/Hashfile.cs
View File

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

222
SabreTools.DatFiles/Formats/Listrom.Reader.cs
View File

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

82
SabreTools.DatFiles/Formats/Listrom.Writer.cs
View File

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

51
SabreTools.DatFiles/Formats/Listrom.cs
View File

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

38
SabreTools.DatFiles/Formats/Listxml.Reader.cs
View File

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

206
SabreTools.DatFiles/Formats/Listxml.Writer.cs
View File

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

206
SabreTools.DatFiles/Formats/Listxml.cs
View File

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

29
SabreTools.DatFiles/Formats/Logiqx.Reader.cs
View File

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

162
SabreTools.DatFiles/Formats/Logiqx.Writer.cs
View File

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

158
SabreTools.DatFiles/Formats/Logiqx.cs
View File

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

17
SabreTools.DatFiles/Formats/Missfile.Reader.cs
View File

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

103
SabreTools.DatFiles/Formats/Missfile.Writer.cs
View File

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

106
SabreTools.DatFiles/Formats/Missfile.cs
View File

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

29
SabreTools.DatFiles/Formats/OfflineList.Reader.cs
View File

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

67
SabreTools.DatFiles/Formats/OfflineList.Writer.cs
View File

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

36
SabreTools.DatFiles/Formats/OfflineList.cs
View File

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

29
SabreTools.DatFiles/Formats/OpenMSX.Reader.cs
View File

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

189
SabreTools.DatFiles/Formats/OpenMSX.Writer.cs
View File

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

38
SabreTools.DatFiles/Formats/OpenMSX.cs
View File

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

29
SabreTools.DatFiles/Formats/RomCenter.Reader.cs
View File

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

71
SabreTools.DatFiles/Formats/RomCenter.Writer.cs
View File

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

40
SabreTools.DatFiles/Formats/RomCenter.cs
View File

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

29
SabreTools.DatFiles/Formats/SeparatedValue.Reader.cs
View File

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

89
SabreTools.DatFiles/Formats/SeparatedValue.Writer.cs
View File

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

104
SabreTools.DatFiles/Formats/SeparatedValue.cs
View File

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

29
SabreTools.DatFiles/Formats/SoftwareList.Reader.cs
View File

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

161
SabreTools.DatFiles/Formats/SoftwareList.Writer.cs
View File

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

132
SabreTools.DatFiles/Formats/SoftwareList.cs
View File

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