SabreTools/SabreTools.Serialization
1
0
Fork 0
mirror of https://github.com/SabreTools/SabreTools.Serialization.git synced 2026-09-22 06:45:11 +00:00
Code Issues 56 Packages Projects Releases 20 Wiki Activity

Convert most keys to properties for Machine

Browse Source
This commit is contained in:
Matt Nadareski
2026-04-04 12:21:09 -04:00
parent eb2f5babd9
commit d72c7c9cc0
34 changed files with 405 additions and 580 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
SabreTools.Data.Models/Metadata/Machine.cs
View File

@@ -8,28 +8,52 @@ namespace SabreTools.Data.Models.Metadata
{
#region Properties
public Adjuster[]? Adjuster { get; set; }
public Archive[]? Archive { get; set; }
public BiosSet[]? BiosSet { get; set; }
public string? Board { get; set; }
public string? Buttons { get; set; }
public Chip[]? Chip { get; set; }
public string? CloneOf { get; set; }
public string? CloneOfId { get; set; }
public string? Company { get; set; }
public Configuration[]? Configuration { get; set; }
public string? Control { get; set; }
public string? Country { get; set; }
public string? Description { get; set; }
public Device[]? Device { get; set; }
public DeviceRef[]? DeviceRef { get; set; }
public DipSwitch[]? DipSwitch { get; set; }
public string? DirName { get; set; }
public Disk[]? Disk { get; set; }
public Display[]? Display { get; set; }
public string? DisplayCount { get; set; }
public string? DisplayType { get; set; }
public Driver? Driver { get; set; }
public Dump[]? Dump { get; set; }
public string? DuplicateID { get; set; }
public string? Emulator { get; set; }
@@ -38,6 +62,8 @@ namespace SabreTools.Data.Models.Metadata
public string? Favorite { get; set; }
public Feature[]? Feature { get; set; }
public string? GenMSXID { get; set; }
public string? Hash { get; set; }
@@ -52,6 +78,10 @@ namespace SabreTools.Data.Models.Metadata
public string? ImageNumber { get; set; }
public Info[]? Info { get; set; }
public Input? Input { get; set; }
/// <remarks>(yes|no) "no"</remarks>
public bool? IsBios { get; set; }
@@ -67,22 +97,34 @@ namespace SabreTools.Data.Models.Metadata
public string? Manufacturer { get; set; }
public Media[]? Media { get; set; }
public string? Name { get; set; }
public string? Notes { get; set; }
public Part[]? Part { get; set; }
public string? PlayedCount { get; set; }
public string? PlayedTime { get; set; }
public string? Players { get; set; }
public Port[]? Port { get; set; }
public string? Publisher { get; set; }
public RamOption[]? RamOption { get; set; }
public string? RebuildTo { get; set; }
public Release[]? Release { get; set; }
public string? ReleaseNumber { get; set; }
public Rom[]? Rom { get; set; }
public string? RomOf { get; set; }
public string? Rotation { get; set; }
@@ -90,10 +132,20 @@ namespace SabreTools.Data.Models.Metadata
/// <remarks>(yes|partial|no) "no"</remarks>
public Runnable? Runnable { get; set; }
public Sample[]? Sample { get; set; }
public string? SampleOf { get; set; }
public string? SaveType { get; set; }
public SharedFeat[]? SharedFeat { get; set; }
public Slot[]? Slot { get; set; }
public SoftwareList[]? SoftwareList { get; set; }
public Sound? Sound { get; set; }
public string? SourceFile { get; set; }
public string? SourceRom { get; set; }
@@ -109,131 +161,25 @@ namespace SabreTools.Data.Models.Metadata
public string? Url { get; set; }
public Video[]? Video { get; set; }
public string? Year { get; set; }
#endregion
#region Keys
/// <remarks>Adjuster[]</remarks>
[NoFilter]
public const string AdjusterKey = "adjuster";
/// <remarks>Archive[]</remarks>
[NoFilter]
public const string ArchiveKey = "archive";
/// <remarks>BiosSet[]</remarks>
[NoFilter]
public const string BiosSetKey = "biosset";
/// <remarks>string, string[]</remarks>
public const string CategoryKey = "category";
/// <remarks>Chip[]</remarks>
[NoFilter]
public const string ChipKey = "chip";
/// <remarks>string, string[]</remarks>
public const string CommentKey = "comment";
/// <remarks>Configuration[]</remarks>
[NoFilter]
public const string ConfigurationKey = "configuration";
/// <remarks>Device[]</remarks>
[NoFilter]
public const string DeviceKey = "device";
/// <remarks>DeviceRef[]</remarks>
[NoFilter]
public const string DeviceRefKey = "device_ref";
/// <remarks>DipSwitch[]</remarks>
[NoFilter]
public const string DipSwitchKey = "dipswitch";
/// <remarks>Disk[]</remarks>
[NoFilter]
public const string DiskKey = "disk";
/// <remarks>Display[]</remarks>
[NoFilter]
public const string DisplayKey = "display";
/// <remarks>Driver</remarks>
[NoFilter]
public const string DriverKey = "driver";
/// <remarks>Dump[]</remarks>
[NoFilter]
public const string DumpKey = "dump";
/// <remarks>Feature[]</remarks>
[NoFilter]
public const string FeatureKey = "feature";
/// <remarks>Info[]</remarks>
[NoFilter]
public const string InfoKey = "info";
/// <remarks>Input</remarks>
[NoFilter]
public const string InputKey = "input";
/// <remarks>Media[]</remarks>
[NoFilter]
public const string MediaKey = "media";
/// <remarks>Part[]</remarks>
[NoFilter]
public const string PartKey = "part";
/// <remarks>Port[]</remarks>
[NoFilter]
public const string PortKey = "port";
/// <remarks>RamOption[]</remarks>
[NoFilter]
public const string RamOptionKey = "ramoption";
/// <remarks>Release[]</remarks>
[NoFilter]
public const string ReleaseKey = "release";
/// <remarks>Rom[]</remarks>
[NoFilter]
public const string RomKey = "rom";
/// <remarks>Sample[]</remarks>
[NoFilter]
public const string SampleKey = "sample";
/// <remarks>SharedFeat[]</remarks>
[NoFilter]
public const string SharedFeatKey = "sharedfeat";
/// <remarks>Slot[]</remarks>
[NoFilter]
public const string SlotKey = "slot";
/// <remarks>SoftwareList[]</remarks>
[NoFilter]
public const string SoftwareListKey = "softwarelist";
/// <remarks>Sound</remarks>
[NoFilter]
public const string SoundKey = "sound";
/// TODO: This needs an internal model OR mapping to fields
/// <remarks>Trurip</remarks>
[NoFilter]
public const string TruripKey = "trurip";
/// <remarks>Video[]</remarks>
[NoFilter]
public const string VideoKey = "video";
#endregion
}
}

54
SabreTools.Metadata.DatFiles.Test/DatFileTests.FromMetadata.cs
View File

@@ -250,74 +250,74 @@ namespace SabreTools.Metadata.DatFiles.Test
{
return new Data.Models.Metadata.Machine
{
[Data.Models.Metadata.Machine.AdjusterKey] = new Data.Models.Metadata.Adjuster[] { CreateMetadataAdjuster() },
[Data.Models.Metadata.Machine.ArchiveKey] = new Data.Models.Metadata.Archive[] { CreateMetadataArchive() },
[Data.Models.Metadata.Machine.BiosSetKey] = new Data.Models.Metadata.BiosSet[] { CreateMetadataBiosSet() },
Adjuster = [CreateMetadataAdjuster()],
Archive = [CreateMetadataArchive()],
BiosSet = [CreateMetadataBiosSet()],
Board = "board",
Buttons = "buttons",
[Data.Models.Metadata.Machine.CategoryKey] = "category",
[Data.Models.Metadata.Machine.ChipKey] = new Data.Models.Metadata.Chip[] { CreateMetadataChip() },
Chip = [CreateMetadataChip()],
CloneOf = "cloneof",
CloneOfId = "cloneofid",
[Data.Models.Metadata.Machine.CommentKey] = "comment",
Company = "company",
[Data.Models.Metadata.Machine.ConfigurationKey] = new Data.Models.Metadata.Configuration[] { CreateMetadataConfiguration() },
Configuration = [CreateMetadataConfiguration()],
Control = "control",
Country = "country",
Description = "description",
[Data.Models.Metadata.Machine.DeviceKey] = new Data.Models.Metadata.Device[] { CreateMetadataDevice() },
[Data.Models.Metadata.Machine.DeviceRefKey] = new Data.Models.Metadata.DeviceRef[] { CreateMetadataDeviceRef() },
[Data.Models.Metadata.Machine.DipSwitchKey] = new Data.Models.Metadata.DipSwitch[] { CreateMetadataDipSwitch() },
Device = [CreateMetadataDevice()],
DeviceRef = [CreateMetadataDeviceRef()],
DipSwitch = [CreateMetadataDipSwitch()],
DirName = "dirname",
[Data.Models.Metadata.Machine.DiskKey] = new Data.Models.Metadata.Disk[] { CreateMetadataDisk() },
Disk = [CreateMetadataDisk()],
DisplayCount = "displaycount",
[Data.Models.Metadata.Machine.DisplayKey] = new Data.Models.Metadata.Display[] { CreateMetadataDisplay() },
Display = [CreateMetadataDisplay()],
DisplayType = "displaytype",
[Data.Models.Metadata.Machine.DriverKey] = CreateMetadataDriver(),
[Data.Models.Metadata.Machine.DumpKey] = new Data.Models.Metadata.Dump[] { CreateMetadataDump() },
Driver = CreateMetadataDriver(),
Dump = [CreateMetadataDump()],
DuplicateID = "duplicateid",
Emulator = "emulator",
Extra = "extra",
Favorite = "favorite",
[Data.Models.Metadata.Machine.FeatureKey] = new Data.Models.Metadata.Feature[] { CreateMetadataFeature() },
Feature = [CreateMetadataFeature()],
GenMSXID = "genmsxid",
History = "history",
Id = "id",
Im1CRC = HashType.CRC32.ZeroString,
Im2CRC = HashType.CRC32.ZeroString,
ImageNumber = "imagenumber",
[Data.Models.Metadata.Machine.InfoKey] = new Data.Models.Metadata.Info[] { CreateMetadataInfo() },
[Data.Models.Metadata.Machine.InputKey] = CreateMetadataInput(),
Info = [CreateMetadataInfo()],
Input = CreateMetadataInput(),
IsBios = true,
IsDevice = true,
IsMechanical = true,
Language = "language",
Location = "location",
Manufacturer = "manufacturer",
[Data.Models.Metadata.Machine.MediaKey] = new Data.Models.Metadata.Media[] { CreateMetadataMedia() },
Media = [CreateMetadataMedia()],
Name = "name",
Notes = "notes",
[Data.Models.Metadata.Machine.PartKey] = new Data.Models.Metadata.Part[] { CreateMetadataPart() },
Part = [CreateMetadataPart()],
PlayedCount = "playedcount",
PlayedTime = "playedtime",
Players = "players",
[Data.Models.Metadata.Machine.PortKey] = new Data.Models.Metadata.Port[] { CreateMetadataPort() },
Port = [CreateMetadataPort()],
Publisher = "publisher",
[Data.Models.Metadata.Machine.RamOptionKey] = new Data.Models.Metadata.RamOption[] { CreateMetadataRamOption() },
RamOption = [CreateMetadataRamOption()],
RebuildTo = "rebuildto",
[Data.Models.Metadata.Machine.ReleaseKey] = new Data.Models.Metadata.Release[] { CreateMetadataRelease() },
Release = [CreateMetadataRelease()],
ReleaseNumber = "releasenumber",
[Data.Models.Metadata.Machine.RomKey] = new Data.Models.Metadata.Rom[] { CreateMetadataRom() },
Rom = [CreateMetadataRom()],
RomOf = "romof",
Rotation = "rotation",
Runnable = Data.Models.Metadata.Runnable.Yes,
[Data.Models.Metadata.Machine.SampleKey] = new Data.Models.Metadata.Sample[] { CreateMetadataSample() },
Sample = [CreateMetadataSample()],
SampleOf = "sampleof",
SaveType = "savetype",
[Data.Models.Metadata.Machine.SharedFeatKey] = new Data.Models.Metadata.SharedFeat[] { CreateMetadataSharedFeat() },
[Data.Models.Metadata.Machine.SlotKey] = new Data.Models.Metadata.Slot[] { CreateMetadataSlot() },
[Data.Models.Metadata.Machine.SoftwareListKey] = new Data.Models.Metadata.SoftwareList[] { CreateMetadataSoftwareList() },
[Data.Models.Metadata.Machine.SoundKey] = CreateMetadataSound(),
SharedFeat = [CreateMetadataSharedFeat()],
Slot = [CreateMetadataSlot()],
SoftwareList = [CreateMetadataSoftwareList()],
Sound = CreateMetadataSound(),
SourceFile = "sourcefile",
SourceRom = "sourcerom",
Status = "status",
@@ -325,7 +325,7 @@ namespace SabreTools.Metadata.DatFiles.Test
System = "system",
Tags = "tags",
[Data.Models.Metadata.Machine.TruripKey] = CreateMetadataTrurip(),
[Data.Models.Metadata.Machine.VideoKey] = new Data.Models.Metadata.Video[] { CreateMetadataVideo() },
Video = [CreateMetadataVideo()],
Year = "year",
};
}

63
SabreTools.Metadata.DatFiles.Test/DatFileTests.ToMetadata.cs
View File

@@ -471,146 +471,143 @@ namespace SabreTools.Metadata.DatFiles.Test
Assert.Equal("tags", machine.Tags);
Assert.Equal("year", machine.Year);
Data.Models.Metadata.Adjuster[]? adjusters = machine.ReadArray<Data.Models.Metadata.Adjuster>(Data.Models.Metadata.Machine.AdjusterKey);
Data.Models.Metadata.Adjuster[]? adjusters = machine.Adjuster;
Assert.NotNull(adjusters);
Data.Models.Metadata.Adjuster adjuster = Assert.Single(adjusters);
ValidateMetadataAdjuster(adjuster);
Data.Models.Metadata.Archive[]? archives = machine.ReadArray<Data.Models.Metadata.Archive>(Data.Models.Metadata.Machine.ArchiveKey);
Data.Models.Metadata.Archive[]? archives = machine.Archive;
Assert.NotNull(archives);
Data.Models.Metadata.Archive archive = Assert.Single(archives);
ValidateMetadataArchive(archive);
Data.Models.Metadata.BiosSet[]? biosSets = machine.ReadArray<Data.Models.Metadata.BiosSet>(Data.Models.Metadata.Machine.BiosSetKey);
Data.Models.Metadata.BiosSet[]? biosSets = machine.BiosSet;
Assert.NotNull(biosSets);
Data.Models.Metadata.BiosSet biosSet = Assert.Single(biosSets);
ValidateMetadataBiosSet(biosSet);
Data.Models.Metadata.Chip[]? chips = machine.ReadArray<Data.Models.Metadata.Chip>(Data.Models.Metadata.Machine.ChipKey);
Data.Models.Metadata.Chip[]? chips = machine.Chip;
Assert.NotNull(chips);
Data.Models.Metadata.Chip chip = Assert.Single(chips);
ValidateMetadataChip(chip);
Data.Models.Metadata.Configuration[]? configurations = machine.ReadArray<Data.Models.Metadata.Configuration>(Data.Models.Metadata.Machine.ConfigurationKey);
Data.Models.Metadata.Configuration[]? configurations = machine.Configuration;
Assert.NotNull(configurations);
Data.Models.Metadata.Configuration configuration = Assert.Single(configurations);
ValidateMetadataConfiguration(configuration);
Data.Models.Metadata.Device[]? devices = machine.ReadArray<Data.Models.Metadata.Device>(Data.Models.Metadata.Machine.DeviceKey);
Data.Models.Metadata.Device[]? devices = machine.Device;
Assert.NotNull(devices);
Data.Models.Metadata.Device device = Assert.Single(devices);
ValidateMetadataDevice(device);
Data.Models.Metadata.DeviceRef[]? deviceRefs = machine.ReadArray<Data.Models.Metadata.DeviceRef>(Data.Models.Metadata.Machine.DeviceRefKey);
Data.Models.Metadata.DeviceRef[]? deviceRefs = machine.DeviceRef;
Assert.NotNull(deviceRefs);
Data.Models.Metadata.DeviceRef deviceRef = Assert.Single(deviceRefs);
ValidateMetadataDeviceRef(deviceRef);
Data.Models.Metadata.DipSwitch[]? dipSwitches = machine.ReadArray<Data.Models.Metadata.DipSwitch>(Data.Models.Metadata.Machine.DipSwitchKey);
Data.Models.Metadata.DipSwitch[]? dipSwitches = machine.DipSwitch;
Assert.NotNull(dipSwitches);
Assert.Equal(2, dipSwitches.Length);
Data.Models.Metadata.DipSwitch dipSwitch = dipSwitches[0];
ValidateMetadataDipSwitch(dipSwitch);
Data.Models.Metadata.Disk[]? disks = machine.ReadArray<Data.Models.Metadata.Disk>(Data.Models.Metadata.Machine.DiskKey);
Data.Models.Metadata.Disk[]? disks = machine.Disk;
Assert.NotNull(disks);
Assert.Equal(2, disks.Length);
Data.Models.Metadata.Disk disk = disks[0];
ValidateMetadataDisk(disk);
Data.Models.Metadata.Display[]? displays = machine.ReadArray<Data.Models.Metadata.Display>(Data.Models.Metadata.Machine.DisplayKey);
Data.Models.Metadata.Display[]? displays = machine.Display;
Assert.NotNull(displays);
Assert.Equal(2, displays.Length);
Data.Models.Metadata.Display? display = Array.Find(displays, d => d.AspectX == null);
ValidateMetadataDisplay(display);
Data.Models.Metadata.Driver[]? drivers = machine.ReadArray<Data.Models.Metadata.Driver>(Data.Models.Metadata.Machine.DriverKey);
Assert.NotNull(drivers);
Data.Models.Metadata.Driver driver = Assert.Single(drivers);
Data.Models.Metadata.Driver? driver = machine.Driver;
Assert.NotNull(driver);
ValidateMetadataDriver(driver);
// TODO: Implement this validation
// Data.Models.Metadata.Dump[]? dumps = machine.ReadArray<Data.Models.Metadata.Dump>(Data.Models.Metadata.Machine.DumpKey);
// Data.Models.Metadata.Dump[]? dumps = machine.Dump;
// Assert.NotNull(dumps);
// Data.Models.Metadata.Dump dump = Assert.Single(dumps);
// ValidateMetadataDump(dump);
Data.Models.Metadata.Feature[]? features = machine.ReadArray<Data.Models.Metadata.Feature>(Data.Models.Metadata.Machine.FeatureKey);
Data.Models.Metadata.Feature[]? features = machine.Feature;
Assert.NotNull(features);
Assert.Equal(2, features.Length);
Data.Models.Metadata.Feature feature = features[0];
ValidateMetadataFeature(feature);
Data.Models.Metadata.Info[]? infos = machine.ReadArray<Data.Models.Metadata.Info>(Data.Models.Metadata.Machine.InfoKey);
Data.Models.Metadata.Info[]? infos = machine.Info;
Assert.NotNull(infos);
Data.Models.Metadata.Info info = Assert.Single(infos);
ValidateMetadataInfo(info);
Data.Models.Metadata.Input[]? inputs = machine.ReadArray<Data.Models.Metadata.Input>(Data.Models.Metadata.Machine.InputKey);
Assert.NotNull(inputs);
Data.Models.Metadata.Input input = Assert.Single(inputs);
Data.Models.Metadata.Input? input = machine.Input;
Assert.NotNull(input);
ValidateMetadataInput(input);
Data.Models.Metadata.Media[]? media = machine.ReadArray<Data.Models.Metadata.Media>(Data.Models.Metadata.Machine.MediaKey);
Data.Models.Metadata.Media[]? media = machine.Media;
Assert.NotNull(media);
Data.Models.Metadata.Media medium = Assert.Single(media);
ValidateMetadataMedia(medium);
Data.Models.Metadata.Part[]? parts = machine.ReadArray<Data.Models.Metadata.Part>(Data.Models.Metadata.Machine.PartKey);
Data.Models.Metadata.Part[]? parts = machine.Part;
Assert.NotNull(parts);
Data.Models.Metadata.Part part = Assert.Single(parts);
ValidateMetadataPart(part);
Data.Models.Metadata.Port[]? ports = machine.ReadArray<Data.Models.Metadata.Port>(Data.Models.Metadata.Machine.PortKey);
Data.Models.Metadata.Port[]? ports = machine.Port;
Assert.NotNull(ports);
Data.Models.Metadata.Port port = Assert.Single(ports);
ValidateMetadataPort(port);
Data.Models.Metadata.RamOption[]? ramOptions = machine.ReadArray<Data.Models.Metadata.RamOption>(Data.Models.Metadata.Machine.RamOptionKey);
Data.Models.Metadata.RamOption[]? ramOptions = machine.RamOption;
Assert.NotNull(ramOptions);
Data.Models.Metadata.RamOption ramOption = Assert.Single(ramOptions);
ValidateMetadataRamOption(ramOption);
Data.Models.Metadata.Release[]? releases = machine.ReadArray<Data.Models.Metadata.Release>(Data.Models.Metadata.Machine.ReleaseKey);
Data.Models.Metadata.Release[]? releases = machine.Release;
Assert.NotNull(releases);
Data.Models.Metadata.Release release = Assert.Single(releases);
ValidateMetadataRelease(release);
Data.Models.Metadata.Rom[]? roms = machine.ReadArray<Data.Models.Metadata.Rom>(Data.Models.Metadata.Machine.RomKey);
Data.Models.Metadata.Rom[]? roms = machine.Rom;
Assert.NotNull(roms);
Assert.Equal(2, roms.Length);
Data.Models.Metadata.Rom rom = roms[0];
ValidateMetadataRom(rom);
Data.Models.Metadata.Sample[]? samples = machine.ReadArray<Data.Models.Metadata.Sample>(Data.Models.Metadata.Machine.SampleKey);
Data.Models.Metadata.Sample[]? samples = machine.Sample;
Assert.NotNull(samples);
Data.Models.Metadata.Sample sample = Assert.Single(samples);
ValidateMetadataSample(sample);
Data.Models.Metadata.SharedFeat[]? sharedFeats = machine.ReadArray<Data.Models.Metadata.SharedFeat>(Data.Models.Metadata.Machine.SharedFeatKey);
Data.Models.Metadata.SharedFeat[]? sharedFeats = machine.SharedFeat;
Assert.NotNull(sharedFeats);
Data.Models.Metadata.SharedFeat sharedFeat = Assert.Single(sharedFeats);
ValidateMetadataSharedFeat(sharedFeat);
Data.Models.Metadata.Slot[]? slots = machine.ReadArray<Data.Models.Metadata.Slot>(Data.Models.Metadata.Machine.SlotKey);
Data.Models.Metadata.Slot[]? slots = machine.Slot;
Assert.NotNull(slots);
Data.Models.Metadata.Slot slot = Assert.Single(slots);
ValidateMetadataSlot(slot);
Data.Models.Metadata.SoftwareList[]? softwareLists = machine.ReadArray<Data.Models.Metadata.SoftwareList>(Data.Models.Metadata.Machine.SoftwareListKey);
Data.Models.Metadata.SoftwareList[]? softwareLists = machine.SoftwareList;
Assert.NotNull(softwareLists);
Data.Models.Metadata.SoftwareList softwareList = Assert.Single(softwareLists);
ValidateMetadataSoftwareList(softwareList);
Data.Models.Metadata.Sound[]? sounds = machine.ReadArray<Data.Models.Metadata.Sound>(Data.Models.Metadata.Machine.SoundKey);
Assert.NotNull(sounds);
Data.Models.Metadata.Sound sound = Assert.Single(sounds);
Data.Models.Metadata.Sound? sound = machine.Sound;
Assert.NotNull(sound);
ValidateMetadataSound(sound);
Data.Models.Logiqx.Trurip? trurip = machine.Read<Data.Models.Logiqx.Trurip>(Data.Models.Metadata.Machine.TruripKey);
ValidateMetadataTrurip(trurip);
Data.Models.Metadata.Video[]? videos = machine.ReadArray<Data.Models.Metadata.Video>(Data.Models.Metadata.Machine.VideoKey);
Data.Models.Metadata.Video[]? videos = machine.Video;
Assert.NotNull(videos);
Data.Models.Metadata.Video video = Assert.Single(videos);
ValidateMetadataVideo(video);

135
SabreTools.Metadata.DatFiles/DatFile.FromMetadata.cs
View File

@@ -237,9 +237,9 @@ namespace SabreTools.Metadata.DatFiles
// long machineIndex = AddMachineDB(machine);
// Convert items in the machine
if (item.ContainsKey(Data.Models.Metadata.Machine.AdjusterKey))
if (item.Adjuster is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Adjuster>(Data.Models.Metadata.Machine.AdjusterKey) ?? [];
var items = item.Adjuster ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -249,9 +249,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.ArchiveKey))
if (item.Archive is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Archive>(Data.Models.Metadata.Machine.ArchiveKey) ?? [];
var items = item.Archive ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -261,9 +261,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.BiosSetKey))
if (item.BiosSet is not null)
{
var items = item.ReadArray<Data.Models.Metadata.BiosSet>(Data.Models.Metadata.Machine.BiosSetKey) ?? [];
var items = item.BiosSet ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -273,9 +273,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.ChipKey))
if (item.Chip is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Chip>(Data.Models.Metadata.Machine.ChipKey) ?? [];
var items = item.Chip ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -285,9 +285,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.ConfigurationKey))
if (item.Configuration is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Configuration>(Data.Models.Metadata.Machine.ConfigurationKey) ?? [];
var items = item.Configuration ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -297,9 +297,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.DeviceKey))
if (item.Device is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Device>(Data.Models.Metadata.Machine.DeviceKey) ?? [];
var items = item.Device ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -309,9 +309,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.DeviceRefKey))
if (item.DeviceRef is not null)
{
var items = item.ReadArray<Data.Models.Metadata.DeviceRef>(Data.Models.Metadata.Machine.DeviceRefKey) ?? [];
var items = item.DeviceRef ?? [];
// Do not filter these due to later use
Array.ForEach(items, item =>
{
@@ -321,9 +321,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.DipSwitchKey))
if (item.DipSwitch is not null)
{
var items = item.ReadArray<Data.Models.Metadata.DipSwitch>(Data.Models.Metadata.Machine.DipSwitchKey) ?? [];
var items = item.DipSwitch ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -333,9 +333,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.DiskKey))
if (item.Disk is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Disk>(Data.Models.Metadata.Machine.DiskKey) ?? [];
var items = item.Disk ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -345,9 +345,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.DisplayKey))
if (item.Display is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Display>(Data.Models.Metadata.Machine.DisplayKey) ?? [];
var items = item.Display ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -357,21 +357,16 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.DriverKey))
if (item.Driver is not null && filterRunner?.Run(item.Driver) != false)
{
var items = item.ReadArray<Data.Models.Metadata.Driver>(Data.Models.Metadata.Machine.DriverKey) ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
var datItem = new Driver(item, machine, source);
AddItem(datItem, statsOnly);
// AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
});
var datItem = new Driver(item.Driver, machine, source);
AddItem(datItem, statsOnly);
// AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
}
if (item.ContainsKey(Data.Models.Metadata.Machine.DumpKey))
if (item.Dump is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Dump>(Data.Models.Metadata.Machine.DumpKey) ?? [];
var items = item.Dump ?? [];
for (int i = 0; i < items.Length; i++)
{
var datItem = new Rom(items[i], machine, source, i);
@@ -383,9 +378,9 @@ namespace SabreTools.Metadata.DatFiles
}
}
if (item.ContainsKey(Data.Models.Metadata.Machine.FeatureKey))
if (item.Feature is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Feature>(Data.Models.Metadata.Machine.FeatureKey) ?? [];
var items = item.Feature ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -395,9 +390,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.InfoKey))
if (item.Info is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Info>(Data.Models.Metadata.Machine.InfoKey) ?? [];
var items = item.Info ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -407,21 +402,16 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.InputKey))
if (item.Input is not null && filterRunner?.Run(item.Input) != false)
{
var items = item.ReadArray<Data.Models.Metadata.Input>(Data.Models.Metadata.Machine.InputKey) ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
var datItem = new Input(item, machine, source);
AddItem(datItem, statsOnly);
// AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
});
var datItem = new Input(item.Input, machine, source);
AddItem(datItem, statsOnly);
// AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
}
if (item.ContainsKey(Data.Models.Metadata.Machine.MediaKey))
if (item.Media is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Media>(Data.Models.Metadata.Machine.MediaKey) ?? [];
var items = item.Media ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -431,15 +421,15 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.PartKey))
if (item.Part is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Part>(Data.Models.Metadata.Machine.PartKey) ?? [];
var items = item.Part ?? [];
ProcessItems(items, machine, machineIndex: 0, source, sourceIndex, statsOnly, filterRunner);
}
if (item.ContainsKey(Data.Models.Metadata.Machine.PortKey))
if (item.Port is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Port>(Data.Models.Metadata.Machine.PortKey) ?? [];
var items = item.Port ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -449,9 +439,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.RamOptionKey))
if (item.RamOption is not null)
{
var items = item.ReadArray<Data.Models.Metadata.RamOption>(Data.Models.Metadata.Machine.RamOptionKey) ?? [];
var items = item.RamOption ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -461,9 +451,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.ReleaseKey))
if (item.Release is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Release>(Data.Models.Metadata.Machine.ReleaseKey) ?? [];
var items = item.Release ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -473,9 +463,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.RomKey))
if (item.Rom is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Rom>(Data.Models.Metadata.Machine.RomKey) ?? [];
var items = item.Rom ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -488,9 +478,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.SampleKey))
if (item.Sample is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Sample>(Data.Models.Metadata.Machine.SampleKey) ?? [];
var items = item.Sample ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -500,9 +490,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.SharedFeatKey))
if (item.SharedFeat is not null)
{
var items = item.ReadArray<Data.Models.Metadata.SharedFeat>(Data.Models.Metadata.Machine.SharedFeatKey) ?? [];
var items = item.SharedFeat ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -512,9 +502,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.SlotKey))
if (item.Slot is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Slot>(Data.Models.Metadata.Machine.SlotKey) ?? [];
var items = item.Slot ?? [];
// Do not filter these due to later use
Array.ForEach(items, item =>
{
@@ -524,9 +514,9 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.SoftwareListKey))
if (item.SoftwareList is not null)
{
var items = item.ReadArray<Data.Models.Metadata.SoftwareList>(Data.Models.Metadata.Machine.SoftwareListKey) ?? [];
var items = item.SoftwareList ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
@@ -536,21 +526,16 @@ namespace SabreTools.Metadata.DatFiles
});
}
if (item.ContainsKey(Data.Models.Metadata.Machine.SoundKey))
if (item.Sound is not null && filterRunner?.Run(item.Sound) != false)
{
var items = item.ReadArray<Data.Models.Metadata.Sound>(Data.Models.Metadata.Machine.SoundKey) ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{
var datItem = new Sound(item, machine, source);
AddItem(datItem, statsOnly);
// AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
});
var datItem = new Sound(item.Sound, machine, source);
AddItem(datItem, statsOnly);
// AddItemDB(datItem, machineIndex, sourceIndex, statsOnly);
}
if (item.ContainsKey(Data.Models.Metadata.Machine.VideoKey))
if (item.Video is not null)
{
var items = item.ReadArray<Data.Models.Metadata.Video>(Data.Models.Metadata.Machine.VideoKey) ?? [];
var items = item.Video ?? [];
var filtered = filterRunner is null ? items : Array.FindAll(items, i => filterRunner.Run(item));
Array.ForEach(filtered, item =>
{

252
SabreTools.Metadata.DatFiles/DatFile.ToMetadata.cs
View File

@@ -115,43 +115,43 @@ namespace SabreTools.Metadata.DatFiles
{
case DatItems.Formats.Adjuster adjuster:
var adjusterItem = adjuster.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Adjuster?>(machine, Data.Models.Metadata.Machine.AdjusterKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.AdjusterKey, adjusterItem);
machine.Adjuster ??= [];
machine.Adjuster = [.. machine.Adjuster, adjusterItem];
break;
case DatItems.Formats.Archive archive:
var archiveItem = archive.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Archive?>(machine, Data.Models.Metadata.Machine.ArchiveKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.ArchiveKey, archiveItem);
machine.Archive ??= [];
machine.Archive = [.. machine.Archive, archiveItem];
break;
case DatItems.Formats.BiosSet biosSet:
var biosSetItem = biosSet.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.BiosSet?>(machine, Data.Models.Metadata.Machine.BiosSetKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.BiosSetKey, biosSetItem);
machine.BiosSet ??= [];
machine.BiosSet = [.. machine.BiosSet, biosSetItem];
break;
case DatItems.Formats.Chip chip:
var chipItem = chip.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Chip?>(machine, Data.Models.Metadata.Machine.ChipKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.ChipKey, chipItem);
machine.Chip ??= [];
machine.Chip = [.. machine.Chip, chipItem];
break;
case DatItems.Formats.Configuration configuration:
var configurationItem = configuration.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Configuration?>(machine, Data.Models.Metadata.Machine.ConfigurationKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.ConfigurationKey, configurationItem);
machine.Configuration ??= [];
machine.Configuration = [.. machine.Configuration, configurationItem];
break;
case DatItems.Formats.Device device:
var deviceItem = device.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Device?>(machine, Data.Models.Metadata.Machine.DeviceKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DeviceKey, deviceItem);
machine.Device ??= [];
machine.Device = [.. machine.Device, deviceItem];
break;
case DatItems.Formats.DeviceRef deviceRef:
var deviceRefItem = deviceRef.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.DeviceRef?>(machine, Data.Models.Metadata.Machine.DeviceRefKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DeviceRefKey, deviceRefItem);
machine.DeviceRef ??= [];
machine.DeviceRef = [.. machine.DeviceRef, deviceRefItem];
break;
case DatItems.Formats.DipSwitch dipSwitch:
var dipSwitchItem = dipSwitch.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.DipSwitch?>(machine, Data.Models.Metadata.Machine.DipSwitchKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DipSwitchKey, dipSwitchItem);
machine.DipSwitch ??= [];
machine.DipSwitch = [.. machine.DipSwitch, dipSwitchItem];
// Add Part mapping
if (dipSwitch.Part is not null)
@@ -160,8 +160,8 @@ namespace SabreTools.Metadata.DatFiles
break;
case DatItems.Formats.Disk disk:
var diskItem = disk.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Disk?>(machine, Data.Models.Metadata.Machine.DiskKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DiskKey, diskItem);
machine.Disk ??= [];
machine.Disk = [.. machine.Disk, diskItem];
// Add Part and DiskArea mappings
if (disk.Part is not null && disk.DiskArea is not null)
@@ -174,38 +174,34 @@ namespace SabreTools.Metadata.DatFiles
break;
case DatItems.Formats.Display display:
var displayItem = ProcessItem(display, machine);
EnsureMachineKey<Data.Models.Metadata.Display?>(machine, Data.Models.Metadata.Machine.DisplayKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DisplayKey, displayItem);
machine.Display ??= [];
machine.Display = [.. machine.Display, displayItem];
break;
case DatItems.Formats.Driver driver:
var driverItem = driver.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Driver?>(machine, Data.Models.Metadata.Machine.DriverKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DriverKey, driverItem);
machine.Driver = driver.GetInternalClone();
break;
case DatItems.Formats.Feature feature:
var featureItem = feature.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Feature?>(machine, Data.Models.Metadata.Machine.FeatureKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.FeatureKey, featureItem);
machine.Feature ??= [];
machine.Feature = [.. machine.Feature, featureItem];
break;
case DatItems.Formats.Info info:
var infoItem = info.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Info?>(machine, Data.Models.Metadata.Machine.InfoKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.InfoKey, infoItem);
machine.Info ??= [];
machine.Info = [.. machine.Info, infoItem];
break;
case DatItems.Formats.Input input:
var inputItem = input.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Input?>(machine, Data.Models.Metadata.Machine.InputKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.InputKey, inputItem);
machine.Input = input.GetInternalClone();
break;
case DatItems.Formats.Media media:
var mediaItem = media.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Media?>(machine, Data.Models.Metadata.Machine.MediaKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.MediaKey, mediaItem);
machine.Media ??= [];
machine.Media = [.. machine.Media, mediaItem];
break;
case DatItems.Formats.PartFeature partFeature:
var partFeatureItem = partFeature.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Feature?>(machine, Data.Models.Metadata.Machine.FeatureKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.FeatureKey, partFeatureItem);
machine.Feature ??= [];
machine.Feature = [.. machine.Feature, partFeatureItem];
// Add Part mapping
if (partFeature.Part is not null)
@@ -214,23 +210,23 @@ namespace SabreTools.Metadata.DatFiles
break;
case DatItems.Formats.Port port:
var portItem = port.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Port?>(machine, Data.Models.Metadata.Machine.PortKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.PortKey, portItem);
machine.Port ??= [];
machine.Port = [.. machine.Port, portItem];
break;
case DatItems.Formats.RamOption ramOption:
var ramOptionItem = ramOption.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.RamOption?>(machine, Data.Models.Metadata.Machine.RamOptionKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.RamOptionKey, ramOptionItem);
machine.RamOption ??= [];
machine.RamOption = [.. machine.RamOption, ramOptionItem];
break;
case DatItems.Formats.Release release:
var releaseItem = release.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Release?>(machine, Data.Models.Metadata.Machine.ReleaseKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.ReleaseKey, releaseItem);
machine.Release ??= [];
machine.Release = [.. machine.Release, releaseItem];
break;
case DatItems.Formats.Rom rom:
var romItem = ProcessItem(rom, machine);
EnsureMachineKey<Data.Models.Metadata.Rom?>(machine, Data.Models.Metadata.Machine.RomKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.RomKey, romItem);
machine.Rom ??= [];
machine.Rom = [.. machine.Rom, romItem];
// Add Part and DataArea mappings
if (rom.Part is not null && rom.DataArea is not null)
@@ -243,28 +239,26 @@ namespace SabreTools.Metadata.DatFiles
break;
case DatItems.Formats.Sample sample:
var sampleItem = sample.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Sample?>(machine, Data.Models.Metadata.Machine.SampleKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.SampleKey, sampleItem);
machine.Sample ??= [];
machine.Sample = [.. machine.Sample, sampleItem];
break;
case DatItems.Formats.SharedFeat sharedFeat:
var sharedFeatItem = sharedFeat.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.SharedFeat?>(machine, Data.Models.Metadata.Machine.SharedFeatKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.SharedFeatKey, sharedFeatItem);
machine.SharedFeat ??= [];
machine.SharedFeat = [.. machine.SharedFeat, sharedFeatItem];
break;
case DatItems.Formats.Slot slot:
var slotItem = slot.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Slot?>(machine, Data.Models.Metadata.Machine.SlotKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.SlotKey, slotItem);
machine.Slot ??= [];
machine.Slot = [.. machine.Slot, slotItem];
break;
case DatItems.Formats.SoftwareList softwareList:
var softwareListItem = softwareList.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.SoftwareList?>(machine, Data.Models.Metadata.Machine.SoftwareListKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.SoftwareListKey, softwareListItem);
machine.SoftwareList ??= [];
machine.SoftwareList = [.. machine.SoftwareList, softwareListItem];
break;
case DatItems.Formats.Sound sound:
var soundItem = sound.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Sound?>(machine, Data.Models.Metadata.Machine.SoundKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.SoundKey, soundItem);
machine.Sound = sound.GetInternalClone();
break;
default:
// This should never happen
@@ -449,7 +443,7 @@ namespace SabreTools.Metadata.DatFiles
}
// Assign the part array to the machine
machine[Data.Models.Metadata.Machine.PartKey] = (Data.Models.Metadata.Part[])[.. partItems.Values];
machine.Part = [.. partItems.Values];
}
// Add the machine to the list
@@ -513,43 +507,43 @@ namespace SabreTools.Metadata.DatFiles
{
case DatItems.Formats.Adjuster adjuster:
var adjusterItem = adjuster.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Adjuster?>(machine, Data.Models.Metadata.Machine.AdjusterKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.AdjusterKey, adjusterItem);
machine.Adjuster ??= [];
machine.Adjuster = [.. machine.Adjuster, adjusterItem];
break;
case DatItems.Formats.Archive archive:
var archiveItem = archive.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Archive?>(machine, Data.Models.Metadata.Machine.ArchiveKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.ArchiveKey, archiveItem);
machine.Archive ??= [];
machine.Archive = [.. machine.Archive, archiveItem];
break;
case DatItems.Formats.BiosSet biosSet:
var biosSetItem = biosSet.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.BiosSet?>(machine, Data.Models.Metadata.Machine.BiosSetKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.BiosSetKey, biosSetItem);
machine.BiosSet ??= [];
machine.BiosSet = [.. machine.BiosSet, biosSetItem];
break;
case DatItems.Formats.Chip chip:
var chipItem = chip.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Chip?>(machine, Data.Models.Metadata.Machine.ChipKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.ChipKey, chipItem);
machine.Chip ??= [];
machine.Chip = [.. machine.Chip, chipItem];
break;
case DatItems.Formats.Configuration configuration:
var configurationItem = configuration.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Configuration?>(machine, Data.Models.Metadata.Machine.ConfigurationKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.ConfigurationKey, configurationItem);
machine.Configuration ??= [];
machine.Configuration = [.. machine.Configuration, configurationItem];
break;
case DatItems.Formats.Device device:
var deviceItem = device.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Device?>(machine, Data.Models.Metadata.Machine.DeviceKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DeviceKey, deviceItem);
machine.Device ??= [];
machine.Device = [.. machine.Device, deviceItem];
break;
case DatItems.Formats.DeviceRef deviceRef:
var deviceRefItem = deviceRef.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.DeviceRef?>(machine, Data.Models.Metadata.Machine.DeviceRefKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DeviceRefKey, deviceRefItem);
machine.DeviceRef ??= [];
machine.DeviceRef = [.. machine.DeviceRef, deviceRefItem];
break;
case DatItems.Formats.DipSwitch dipSwitch:
var dipSwitchItem = dipSwitch.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.DipSwitch?>(machine, Data.Models.Metadata.Machine.DipSwitchKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DipSwitchKey, dipSwitchItem);
machine.DipSwitch ??= [];
machine.DipSwitch = [.. machine.DipSwitch, dipSwitchItem];
// Add Part mapping
if (dipSwitch.Part is not null)
@@ -558,8 +552,8 @@ namespace SabreTools.Metadata.DatFiles
break;
case DatItems.Formats.Disk disk:
var diskItem = disk.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Disk?>(machine, Data.Models.Metadata.Machine.DiskKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DiskKey, diskItem);
machine.Disk ??= [];
machine.Disk = [.. machine.Disk, diskItem];
// Add Part and DiskArea mappings
if (disk.Part is not null && disk.DiskArea is not null)
@@ -572,38 +566,34 @@ namespace SabreTools.Metadata.DatFiles
break;
case DatItems.Formats.Display display:
var displayItem = ProcessItem(display, machine);
EnsureMachineKey<Data.Models.Metadata.Display?>(machine, Data.Models.Metadata.Machine.DisplayKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DisplayKey, displayItem);
machine.Display ??= [];
machine.Display = [.. machine.Display, displayItem];
break;
case DatItems.Formats.Driver driver:
var driverItem = driver.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Driver?>(machine, Data.Models.Metadata.Machine.DriverKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DriverKey, driverItem);
machine.Driver = driver.GetInternalClone();
break;
case DatItems.Formats.Feature feature:
var featureItem = feature.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Feature?>(machine, Data.Models.Metadata.Machine.FeatureKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.FeatureKey, featureItem);
machine.Feature ??= [];
machine.Feature = [.. machine.Feature, featureItem];
break;
case DatItems.Formats.Info info:
var infoItem = info.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Info?>(machine, Data.Models.Metadata.Machine.InfoKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.InfoKey, infoItem);
machine.Info ??= [];
machine.Info = [.. machine.Info, infoItem];
break;
case DatItems.Formats.Input input:
var inputItem = input.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Input?>(machine, Data.Models.Metadata.Machine.InputKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.InputKey, inputItem);
machine.Input = input.GetInternalClone();
break;
case DatItems.Formats.Media media:
var mediaItem = media.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Media?>(machine, Data.Models.Metadata.Machine.MediaKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.MediaKey, mediaItem);
machine.Media ??= [];
machine.Media = [.. machine.Media, mediaItem];
break;
case DatItems.Formats.PartFeature partFeature:
var partFeatureItem = partFeature.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Feature?>(machine, Data.Models.Metadata.Machine.FeatureKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.FeatureKey, partFeatureItem);
machine.Feature ??= [];
machine.Feature = [.. machine.Feature, partFeatureItem];
// Add Part mapping
if (partFeature.Part is not null)
@@ -612,23 +602,23 @@ namespace SabreTools.Metadata.DatFiles
break;
case DatItems.Formats.Port port:
var portItem = port.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Port?>(machine, Data.Models.Metadata.Machine.PortKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.PortKey, portItem);
machine.Port ??= [];
machine.Port = [.. machine.Port, portItem];
break;
case DatItems.Formats.RamOption ramOption:
var ramOptionItem = ramOption.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.RamOption?>(machine, Data.Models.Metadata.Machine.RamOptionKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.RamOptionKey, ramOptionItem);
machine.RamOption ??= [];
machine.RamOption = [.. machine.RamOption, ramOptionItem];
break;
case DatItems.Formats.Release release:
var releaseItem = release.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Release?>(machine, Data.Models.Metadata.Machine.ReleaseKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.ReleaseKey, releaseItem);
machine.Release ??= [];
machine.Release = [.. machine.Release, releaseItem];
break;
case DatItems.Formats.Rom rom:
var romItem = ProcessItem(rom, machine);
EnsureMachineKey<Data.Models.Metadata.Rom?>(machine, Data.Models.Metadata.Machine.RomKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.RomKey, romItem);
machine.Rom ??= [];
machine.Rom = [.. machine.Rom, romItem];
// Add Part and DataArea mappings
if (rom.Part is not null && rom.DataArea is not null)
@@ -641,28 +631,26 @@ namespace SabreTools.Metadata.DatFiles
break;
case DatItems.Formats.Sample sample:
var sampleItem = sample.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Sample?>(machine, Data.Models.Metadata.Machine.SampleKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.SampleKey, sampleItem);
machine.Sample ??= [];
machine.Sample = [.. machine.Sample, sampleItem];
break;
case DatItems.Formats.SharedFeat sharedFeat:
var sharedFeatItem = sharedFeat.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.SharedFeat?>(machine, Data.Models.Metadata.Machine.SharedFeatKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.SharedFeatKey, sharedFeatItem);
machine.SharedFeat ??= [];
machine.SharedFeat = [.. machine.SharedFeat, sharedFeatItem];
break;
case DatItems.Formats.Slot slot:
var slotItem = slot.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Slot?>(machine, Data.Models.Metadata.Machine.SlotKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.SlotKey, slotItem);
machine.Slot ??= [];
machine.Slot = [.. machine.Slot, slotItem];
break;
case DatItems.Formats.SoftwareList softwareList:
var softwareListItem = softwareList.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.SoftwareList?>(machine, Data.Models.Metadata.Machine.SoftwareListKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.SoftwareListKey, softwareListItem);
machine.SoftwareList ??= [];
machine.SoftwareList = [.. machine.SoftwareList, softwareListItem];
break;
case DatItems.Formats.Sound sound:
var soundItem = sound.GetInternalClone();
EnsureMachineKey<Data.Models.Metadata.Sound?>(machine, Data.Models.Metadata.Machine.SoundKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.SoundKey, soundItem);
machine.Sound = sound.GetInternalClone();
break;
default:
// This should never happen
@@ -847,7 +835,7 @@ namespace SabreTools.Metadata.DatFiles
}
// Assign the part array to the machine
machine[Data.Models.Metadata.Machine.PartKey] = (Data.Models.Metadata.Part[])[.. partItems.Values];
machine.Part = [.. partItems.Values];
}
// Add the machine to the list
@@ -885,8 +873,8 @@ namespace SabreTools.Metadata.DatFiles
Width = displayItem.Width,
};
EnsureMachineKey<Data.Models.Metadata.Video?>(machine, Data.Models.Metadata.Machine.VideoKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.VideoKey, videoItem);
machine.Video ??= [];
machine.Video = [.. machine.Video, videoItem];
}
return displayItem;
@@ -932,8 +920,8 @@ namespace SabreTools.Metadata.DatFiles
dumpRom[Data.Models.Metadata.Dump.OriginalKey] = newOriginal;
}
EnsureMachineKey<Data.Models.Metadata.Dump?>(machine, Data.Models.Metadata.Machine.DumpKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DumpKey, dumpRom);
machine.Dump ??= [];
machine.Dump = [.. machine.Dump, dumpRom];
break;
case OpenMSXSubType.MegaRom:
@@ -960,8 +948,8 @@ namespace SabreTools.Metadata.DatFiles
dumpMegaRom[Data.Models.Metadata.Dump.OriginalKey] = newOriginal;
}
EnsureMachineKey<Data.Models.Metadata.Dump?>(machine, Data.Models.Metadata.Machine.DumpKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DumpKey, dumpMegaRom);
machine.Dump ??= [];
machine.Dump = [.. machine.Dump, dumpMegaRom];
break;
case OpenMSXSubType.SCCPlusCart:
@@ -988,8 +976,8 @@ namespace SabreTools.Metadata.DatFiles
dumpSccPlusCart[Data.Models.Metadata.Dump.OriginalKey] = newOriginal;
}
EnsureMachineKey<Data.Models.Metadata.Dump?>(machine, Data.Models.Metadata.Machine.DumpKey);
AppendToMachineKey(machine, Data.Models.Metadata.Machine.DumpKey, dumpSccPlusCart);
machine.Dump ??= [];
machine.Dump = [.. machine.Dump, dumpSccPlusCart];
break;
default:
// This should never happen
@@ -999,38 +987,6 @@ namespace SabreTools.Metadata.DatFiles
return romItem;
}
/// <summary>
/// Ensure a key in a machine
/// </summary>
private static void EnsureMachineKey<T>(Data.Models.Metadata.Machine machine, string key)
{
if (machine.Read<T[]?>(key) is null)
#if NET20 || NET35 || NET40 || NET452
machine[key] = new T[0];
#else
machine[key] = System.Array.Empty<T>();
#endif
}
/// <summary>
/// Append to a machine key as if its an array
/// </summary>
private static void AppendToMachineKey<T>(Data.Models.Metadata.Machine machine, string key, T value) where T : Data.Models.Metadata.DatItem
{
// Get the existing array
var arr = machine.Read<T[]>(key);
if (arr is null)
return;
// Trim all null fields
ClearEmptyKeys(value);
// Add to the array
List<T> list = [.. arr];
list.Add(value);
machine[key] = list.ToArray();
}
/// <summary>
/// Clear empty keys from a DictionaryBase object
/// </summary>

29
SabreTools.Metadata.DatItems/Machine.cs
View File

@@ -321,36 +321,7 @@ namespace SabreTools.Metadata.DatItems
public Machine(Data.Models.Metadata.Machine machine)
{
_internal = machine.DeepClone() as Data.Models.Metadata.Machine ?? [];
// Remove all inverted fields
Remove(Data.Models.Metadata.Machine.AdjusterKey);
Remove(Data.Models.Metadata.Machine.ArchiveKey);
Remove(Data.Models.Metadata.Machine.BiosSetKey);
Remove(Data.Models.Metadata.Machine.ChipKey);
Remove(Data.Models.Metadata.Machine.ConfigurationKey);
Remove(Data.Models.Metadata.Machine.DeviceKey);
Remove(Data.Models.Metadata.Machine.DeviceRefKey);
Remove(Data.Models.Metadata.Machine.DipSwitchKey);
Remove(Data.Models.Metadata.Machine.DiskKey);
Remove(Data.Models.Metadata.Machine.DisplayKey);
Remove(Data.Models.Metadata.Machine.DriverKey);
Remove(Data.Models.Metadata.Machine.DumpKey);
Remove(Data.Models.Metadata.Machine.FeatureKey);
Remove(Data.Models.Metadata.Machine.InfoKey);
Remove(Data.Models.Metadata.Machine.InputKey);
Remove(Data.Models.Metadata.Machine.MediaKey);
Remove(Data.Models.Metadata.Machine.PartKey);
Remove(Data.Models.Metadata.Machine.PortKey);
Remove(Data.Models.Metadata.Machine.RamOptionKey);
Remove(Data.Models.Metadata.Machine.ReleaseKey);
Remove(Data.Models.Metadata.Machine.RomKey);
Remove(Data.Models.Metadata.Machine.SampleKey);
Remove(Data.Models.Metadata.Machine.SharedFeatKey);
Remove(Data.Models.Metadata.Machine.SlotKey);
Remove(Data.Models.Metadata.Machine.SoftwareListKey);
Remove(Data.Models.Metadata.Machine.SoundKey);
Remove(Data.Models.Metadata.Machine.TruripKey);
Remove(Data.Models.Metadata.Machine.VideoKey);
// Process flag values
if (Im1CRC is not null)

2
SabreTools.Serialization.CrossModel/ArchiveDotOrg.Deserializer.cs
View File

@@ -30,7 +30,7 @@ namespace SabreTools.Serialization.CrossModel
/// </summary>
private static File[] ConvertFromInternalModel(Data.Models.Metadata.Machine item)
{
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is null)
return [];

2
SabreTools.Serialization.CrossModel/ArchiveDotOrg.Serializer.cs
View File

@@ -47,7 +47,7 @@ namespace SabreTools.Serialization.CrossModel
var rom = ConvertToInternalModel(item);
if (rom is not null)
machine[Data.Models.Metadata.Machine.RomKey] = new Data.Models.Metadata.Rom[] { rom };
machine.Rom = new Data.Models.Metadata.Rom[] { rom };
return machine;
}

2
SabreTools.Serialization.CrossModel/AttractMode.Deserializer.cs
View File

@@ -43,7 +43,7 @@ namespace SabreTools.Serialization.CrossModel
/// </summary>
private static Row[] ConvertMachineFromInternalModel(Data.Models.Metadata.Machine item)
{
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is null || roms.Length == 0)
return [];

2
SabreTools.Serialization.CrossModel/AttractMode.Serializer.cs
View File

@@ -65,7 +65,7 @@ namespace SabreTools.Serialization.CrossModel
Tags = item.Tags,
PlayedCount = item.PlayedCount,
PlayedTime = item.PlayedTime,
[Data.Models.Metadata.Machine.RomKey] = new Data.Models.Metadata.Rom[] { ConvertToInternalModel(item) },
Rom = [ConvertToInternalModel(item)],
};
return machine;
}

26
SabreTools.Serialization.CrossModel/ClrMamePro.Deserializer.cs
View File

@@ -79,55 +79,55 @@ namespace SabreTools.Serialization.CrossModel
gameBase.RomOf = item.RomOf;
gameBase.SampleOf = item.SampleOf;
var releases = item.Read<Data.Models.Metadata.Release[]>(Data.Models.Metadata.Machine.ReleaseKey);
var releases = item.Release;
if (releases is not null && releases.Length > 0)
gameBase.Release = Array.ConvertAll(releases, ConvertFromInternalModel);
var biosSets = item.Read<Data.Models.Metadata.BiosSet[]>(Data.Models.Metadata.Machine.BiosSetKey);
var biosSets = item.BiosSet;
if (biosSets is not null && biosSets.Length > 0)
gameBase.BiosSet = Array.ConvertAll(biosSets, ConvertFromInternalModel);
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is not null && roms.Length > 0)
gameBase.Rom = Array.ConvertAll(roms, ConvertFromInternalModel);
var disks = item.Read<Data.Models.Metadata.Disk[]>(Data.Models.Metadata.Machine.DiskKey);
var disks = item.Disk;
if (disks is not null && disks.Length > 0)
gameBase.Disk = Array.ConvertAll(disks, ConvertFromInternalModel);
var medias = item.Read<Data.Models.Metadata.Media[]>(Data.Models.Metadata.Machine.MediaKey);
var medias = item.Media;
if (medias is not null && medias.Length > 0)
gameBase.Media = Array.ConvertAll(medias, ConvertFromInternalModel);
var samples = item.Read<Data.Models.Metadata.Sample[]>(Data.Models.Metadata.Machine.SampleKey);
var samples = item.Sample;
if (samples is not null && samples.Length > 0)
gameBase.Sample = Array.ConvertAll(samples, ConvertFromInternalModel);
var archives = item.Read<Data.Models.Metadata.Archive[]>(Data.Models.Metadata.Machine.ArchiveKey);
var archives = item.Archive;
if (archives is not null && archives.Length > 0)
gameBase.Archive = Array.ConvertAll(archives, ConvertFromInternalModel);
var chips = item.Read<Data.Models.Metadata.Chip[]>(Data.Models.Metadata.Machine.ChipKey);
var chips = item.Chip;
if (chips is not null && chips.Length > 0)
gameBase.Chip = Array.ConvertAll(chips, ConvertFromInternalModel);
var videos = item.Read<Data.Models.Metadata.Video[]>(Data.Models.Metadata.Machine.VideoKey);
var videos = item.Video;
if (videos is not null && videos.Length > 0)
gameBase.Video = Array.ConvertAll(videos, ConvertFromInternalModel);
var sound = item.Read<Data.Models.Metadata.Sound>(Data.Models.Metadata.Machine.SoundKey);
var sound = item.Sound;
if (sound is not null)
gameBase.Sound = ConvertFromInternalModel(sound);
var input = item.Read<Data.Models.Metadata.Input>(Data.Models.Metadata.Machine.InputKey);
var input = item.Input;
if (input is not null)
gameBase.Input = ConvertFromInternalModel(input);
var dipSwitches = item.Read<Data.Models.Metadata.DipSwitch[]>(Data.Models.Metadata.Machine.DipSwitchKey);
var dipSwitches = item.DipSwitch;
if (dipSwitches is not null && dipSwitches.Length > 0)
gameBase.DipSwitch = Array.ConvertAll(dipSwitches, ConvertFromInternalModel);
var driver = item.Read<Data.Models.Metadata.Driver>(Data.Models.Metadata.Machine.DriverKey);
var driver = item.Driver;
if (driver is not null)
gameBase.Driver = ConvertFromInternalModel(driver);

58
SabreTools.Serialization.CrossModel/ClrMamePro.Serializer.cs
View File

@@ -66,7 +66,7 @@ namespace SabreTools.Serialization.CrossModel
{
Name = item.Name,
Description = item.Description,
// [Data.Models.Metadata.Machine.DriverKey] = item.DriverStatus, // TODO: Needs metadata mapping
// Driver = item.DriverStatus, // TODO: Needs metadata mapping
Year = item.Year,
Manufacturer = item.Manufacturer,
[Data.Models.Metadata.Machine.CategoryKey] = item.Category,
@@ -76,73 +76,43 @@ namespace SabreTools.Serialization.CrossModel
};
if (item.Release is not null && item.Release.Length > 0)
{
machine[Data.Models.Metadata.Machine.ReleaseKey]
= Array.ConvertAll(item.Release, ConvertToInternalModel);
}
machine.Release = Array.ConvertAll(item.Release, ConvertToInternalModel);
if (item.BiosSet is not null && item.BiosSet.Length > 0)
{
machine[Data.Models.Metadata.Machine.BiosSetKey]
= Array.ConvertAll(item.BiosSet, ConvertToInternalModel);
}
machine.BiosSet = Array.ConvertAll(item.BiosSet, ConvertToInternalModel);
if (item.Rom is not null && item.Rom.Length > 0)
{
machine[Data.Models.Metadata.Machine.RomKey]
= Array.ConvertAll(item.Rom, ConvertToInternalModel);
}
machine.Rom = Array.ConvertAll(item.Rom, ConvertToInternalModel);
if (item.Disk is not null && item.Disk.Length > 0)
{
machine[Data.Models.Metadata.Machine.DiskKey]
= Array.ConvertAll(item.Disk, ConvertToInternalModel);
}
machine.Disk = Array.ConvertAll(item.Disk, ConvertToInternalModel);
if (item.Media is not null && item.Media.Length > 0)
{
machine[Data.Models.Metadata.Machine.MediaKey]
= Array.ConvertAll(item.Media, ConvertToInternalModel);
}
machine.Media = Array.ConvertAll(item.Media, ConvertToInternalModel);
if (item.Sample is not null && item.Sample.Length > 0)
{
machine[Data.Models.Metadata.Machine.SampleKey]
= Array.ConvertAll(item.Sample, ConvertToInternalModel);
}
machine.Sample = Array.ConvertAll(item.Sample, ConvertToInternalModel);
if (item.Archive is not null && item.Archive.Length > 0)
{
machine[Data.Models.Metadata.Machine.ArchiveKey]
= Array.ConvertAll(item.Archive, ConvertToInternalModel);
}
machine.Archive = Array.ConvertAll(item.Archive, ConvertToInternalModel);
if (item.Chip is not null && item.Chip.Length > 0)
{
machine[Data.Models.Metadata.Machine.ChipKey]
= Array.ConvertAll(item.Chip, ConvertToInternalModel);
}
machine.Chip = Array.ConvertAll(item.Chip, ConvertToInternalModel);
if (item.Video is not null)
{
machine[Data.Models.Metadata.Machine.VideoKey]
= Array.ConvertAll(item.Video, ConvertToInternalModel);
}
machine.Video = Array.ConvertAll(item.Video, ConvertToInternalModel);
if (item.Sound is not null)
machine[Data.Models.Metadata.Machine.SoundKey] = ConvertToInternalModel(item.Sound);
machine.Sound = ConvertToInternalModel(item.Sound);
if (item.Input is not null)
machine[Data.Models.Metadata.Machine.InputKey] = ConvertToInternalModel(item.Input);
machine.Input = ConvertToInternalModel(item.Input);
if (item.DipSwitch is not null && item.DipSwitch.Length > 0)
{
machine[Data.Models.Metadata.Machine.DipSwitchKey]
= Array.ConvertAll(item.DipSwitch, ConvertToInternalModel);
}
machine.DipSwitch = Array.ConvertAll(item.DipSwitch, ConvertToInternalModel);
if (item.Driver is not null)
machine[Data.Models.Metadata.Machine.DriverKey] = ConvertToInternalModel(item.Driver);
machine.Driver = ConvertToInternalModel(item.Driver);
return machine;
}

2
SabreTools.Serialization.CrossModel/DosCenter.Deserializer.cs
View File

@@ -52,7 +52,7 @@ namespace SabreTools.Serialization.CrossModel
Name = item.Name,
};
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is not null && roms.Length > 0)
game.File = Array.ConvertAll(roms, ConvertFromInternalModel);

2
SabreTools.Serialization.CrossModel/DosCenter.Serializer.cs
View File

@@ -55,7 +55,7 @@ namespace SabreTools.Serialization.CrossModel
if (item.File is not null && item.File.Length > 0)
{
machine[Data.Models.Metadata.Machine.RomKey]
machine.Rom
= Array.ConvertAll(item.File, ConvertToInternalModel);
}

2
SabreTools.Serialization.CrossModel/EverdriveSMDB.Deserializer.cs
View File

@@ -31,7 +31,7 @@ namespace SabreTools.Serialization.CrossModel
/// </summary>
private static Row[] ConvertMachineFromInternalModel(Data.Models.Metadata.Machine item)
{
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is null || roms.Length == 0)
return [];

2
SabreTools.Serialization.CrossModel/EverdriveSMDB.Serializer.cs
View File

@@ -44,7 +44,7 @@ namespace SabreTools.Serialization.CrossModel
{
var machine = new Data.Models.Metadata.Machine
{
[Data.Models.Metadata.Machine.RomKey] = new Data.Models.Metadata.Rom[] { ConvertToInternalModel(item) },
Rom = new Data.Models.Metadata.Rom[] { ConvertToInternalModel(item) },
};
return machine;
}

2
SabreTools.Serialization.CrossModel/Hashfile.Deserializer.cs
View File

@@ -96,7 +96,7 @@ namespace SabreTools.Serialization.CrossModel
/// </summary>
private static Data.Models.Hashfile.Hashfile ConvertMachineFromInternalModel(Data.Models.Metadata.Machine item, HashType hash)
{
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is null)
return new Data.Models.Hashfile.Hashfile();

22
SabreTools.Serialization.CrossModel/Hashfile.Serializer.cs
View File

@@ -42,27 +42,27 @@ namespace SabreTools.Serialization.CrossModel
var machine = new Data.Models.Metadata.Machine();
if (item.SFV is not null && item.SFV.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.SFV, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.SFV, ConvertToInternalModel);
else if (item.MD2 is not null && item.MD2.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.MD2, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.MD2, ConvertToInternalModel);
else if (item.MD4 is not null && item.MD4.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.MD4, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.MD4, ConvertToInternalModel);
else if (item.MD5 is not null && item.MD5.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.MD5, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.MD5, ConvertToInternalModel);
else if (item.RIPEMD128 is not null && item.RIPEMD128.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.RIPEMD128, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.RIPEMD128, ConvertToInternalModel);
else if (item.RIPEMD160 is not null && item.RIPEMD160.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.RIPEMD160, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.RIPEMD160, ConvertToInternalModel);
else if (item.SHA1 is not null && item.SHA1.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.SHA1, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.SHA1, ConvertToInternalModel);
else if (item.SHA256 is not null && item.SHA256.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.SHA256, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.SHA256, ConvertToInternalModel);
else if (item.SHA384 is not null && item.SHA384.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.SHA384, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.SHA384, ConvertToInternalModel);
else if (item.SHA512 is not null && item.SHA512.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.SHA512, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.SHA512, ConvertToInternalModel);
else if (item.SpamSum is not null && item.SpamSum.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.SpamSum, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.SpamSum, ConvertToInternalModel);
return machine;
}

4
SabreTools.Serialization.CrossModel/Listrom.Deserializer.cs
View File

@@ -34,13 +34,13 @@ namespace SabreTools.Serialization.CrossModel
var rowItems = new List<Row>();
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is not null)
{
rowItems.AddRange(Array.ConvertAll(roms, ConvertFromInternalModel));
}
var disks = item.Read<Data.Models.Metadata.Disk[]>(Data.Models.Metadata.Machine.DiskKey);
var disks = item.Disk;
if (disks is not null)
rowItems.AddRange(Array.ConvertAll(disks, ConvertFromInternalModel));

4
SabreTools.Serialization.CrossModel/Listrom.Serializer.cs
View File

@@ -67,8 +67,8 @@ namespace SabreTools.Serialization.CrossModel
roms.Add(rom);
}
machine[Data.Models.Metadata.Machine.DiskKey] = disks.ToArray();
machine[Data.Models.Metadata.Machine.RomKey] = roms.ToArray();
machine.Disk = disks.ToArray();
machine.Rom = roms.ToArray();
}
return machine;

40
SabreTools.Serialization.CrossModel/Listxml.Deserializer.cs
View File

@@ -58,83 +58,83 @@ namespace SabreTools.Serialization.CrossModel
History = item.History,
};
var biosSets = item.Read<Data.Models.Metadata.BiosSet[]>(Data.Models.Metadata.Machine.BiosSetKey);
var biosSets = item.BiosSet;
if (biosSets is not null && biosSets.Length > 0)
machine.BiosSet = Array.ConvertAll(biosSets, ConvertFromInternalModel);
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is not null && roms.Length > 0)
machine.Rom = Array.ConvertAll(roms, ConvertFromInternalModel);
var disks = item.Read<Data.Models.Metadata.Disk[]>(Data.Models.Metadata.Machine.DiskKey);
var disks = item.Disk;
if (disks is not null && disks.Length > 0)
machine.Disk = Array.ConvertAll(disks, ConvertFromInternalModel);
var deviceRefs = item.Read<Data.Models.Metadata.DeviceRef[]>(Data.Models.Metadata.Machine.DeviceRefKey);
var deviceRefs = item.DeviceRef;
if (deviceRefs is not null && deviceRefs.Length > 0)
machine.DeviceRef = Array.ConvertAll(deviceRefs, ConvertFromInternalModel);
var samples = item.Read<Data.Models.Metadata.Sample[]>(Data.Models.Metadata.Machine.SampleKey);
var samples = item.Sample;
if (samples is not null && samples.Length > 0)
machine.Sample = Array.ConvertAll(samples, ConvertFromInternalModel);
var chips = item.Read<Data.Models.Metadata.Chip[]>(Data.Models.Metadata.Machine.ChipKey);
var chips = item.Chip;
if (chips is not null && chips.Length > 0)
machine.Chip = Array.ConvertAll(chips, ConvertFromInternalModel);
var displays = item.Read<Data.Models.Metadata.Display[]>(Data.Models.Metadata.Machine.DisplayKey);
var displays = item.Display;
if (displays is not null && displays.Length > 0)
machine.Display = Array.ConvertAll(displays, ConvertFromInternalModel);
var videos = item.Read<Data.Models.Metadata.Video[]>(Data.Models.Metadata.Machine.VideoKey);
var videos = item.Video;
if (videos is not null && videos.Length > 0)
machine.Video = Array.ConvertAll(videos, ConvertFromInternalModel);
var sound = item.Read<Data.Models.Metadata.Sound>(Data.Models.Metadata.Machine.SoundKey);
var sound = item.Sound;
if (sound is not null)
machine.Sound = ConvertFromInternalModel(sound);
var input = item.Read<Data.Models.Metadata.Input>(Data.Models.Metadata.Machine.InputKey);
var input = item.Input;
if (input is not null)
machine.Input = ConvertFromInternalModel(input);
var dipSwitches = item.Read<Data.Models.Metadata.DipSwitch[]>(Data.Models.Metadata.Machine.DipSwitchKey);
var dipSwitches = item.DipSwitch;
if (dipSwitches is not null && dipSwitches.Length > 0)
machine.DipSwitch = Array.ConvertAll(dipSwitches, ConvertFromInternalModel);
var configurations = item.Read<Data.Models.Metadata.Configuration[]>(Data.Models.Metadata.Machine.ConfigurationKey);
var configurations = item.Configuration;
if (configurations is not null && configurations.Length > 0)
machine.Configuration = Array.ConvertAll(configurations, ConvertFromInternalModel);
var ports = item.Read<Data.Models.Metadata.Port[]>(Data.Models.Metadata.Machine.PortKey);
var ports = item.Port;
if (ports is not null && ports.Length > 0)
machine.Port = Array.ConvertAll(ports, ConvertFromInternalModel);
var adjusters = item.Read<Data.Models.Metadata.Adjuster[]>(Data.Models.Metadata.Machine.AdjusterKey);
var adjusters = item.Adjuster;
if (adjusters is not null && adjusters.Length > 0)
machine.Adjuster = Array.ConvertAll(adjusters, ConvertFromInternalModel);
var driver = item.Read<Data.Models.Metadata.Driver>(Data.Models.Metadata.Machine.DriverKey);
var driver = item.Driver;
if (driver is not null)
machine.Driver = ConvertFromInternalModel(driver);
var features = item.Read<Data.Models.Metadata.Feature[]>(Data.Models.Metadata.Machine.FeatureKey);
var features = item.Feature;
if (features is not null && features.Length > 0)
machine.Feature = Array.ConvertAll(features, ConvertFromInternalModel);
var devices = item.Read<Data.Models.Metadata.Device[]>(Data.Models.Metadata.Machine.DeviceKey);
var devices = item.Device;
if (devices is not null && devices.Length > 0)
machine.Device = Array.ConvertAll(devices, ConvertFromInternalModel);
var slots = item.Read<Data.Models.Metadata.Slot[]>(Data.Models.Metadata.Machine.SlotKey);
var slots = item.Slot;
if (slots is not null && slots.Length > 0)
machine.Slot = Array.ConvertAll(slots, ConvertFromInternalModel);
var softwareLists = item.Read<Data.Models.Metadata.SoftwareList[]>(Data.Models.Metadata.Machine.SoftwareListKey);
var softwareLists = item.SoftwareList;
if (softwareLists is not null && softwareLists.Length > 0)
machine.SoftwareList = Array.ConvertAll(softwareLists, ConvertFromInternalModel);
var ramOptions = item.Read<Data.Models.Metadata.RamOption[]>(Data.Models.Metadata.Machine.RamOptionKey);
var ramOptions = item.RamOption;
if (ramOptions is not null && ramOptions.Length > 0)
machine.RamOption = Array.ConvertAll(ramOptions, ConvertFromInternalModel);

40
SabreTools.Serialization.CrossModel/Listxml.Serializer.cs
View File

@@ -63,112 +63,112 @@ namespace SabreTools.Serialization.CrossModel
if (item.BiosSet is not null && item.BiosSet.Length > 0)
{
machine[Data.Models.Metadata.Machine.BiosSetKey]
machine.BiosSet
= Array.ConvertAll(item.BiosSet, ConvertToInternalModel);
}
if (item.Rom is not null && item.Rom.Length > 0)
{
machine[Data.Models.Metadata.Machine.RomKey]
machine.Rom
= Array.ConvertAll(item.Rom, ConvertToInternalModel);
}
if (item.Disk is not null && item.Disk.Length > 0)
{
machine[Data.Models.Metadata.Machine.DiskKey]
machine.Disk
= Array.ConvertAll(item.Disk, ConvertToInternalModel);
}
if (item.DeviceRef is not null && item.DeviceRef.Length > 0)
{
machine[Data.Models.Metadata.Machine.DeviceRefKey]
machine.DeviceRef
= Array.ConvertAll(item.DeviceRef, ConvertToInternalModel);
}
if (item.Sample is not null && item.Sample.Length > 0)
{
machine[Data.Models.Metadata.Machine.SampleKey]
machine.Sample
= Array.ConvertAll(item.Sample, ConvertToInternalModel);
}
if (item.Chip is not null && item.Chip.Length > 0)
{
machine[Data.Models.Metadata.Machine.ChipKey]
machine.Chip
= Array.ConvertAll(item.Chip, ConvertToInternalModel);
}
if (item.Display is not null && item.Display.Length > 0)
{
machine[Data.Models.Metadata.Machine.DisplayKey]
machine.Display
= Array.ConvertAll(item.Display, ConvertToInternalModel);
}
if (item.Video is not null && item.Video.Length > 0)
{
machine[Data.Models.Metadata.Machine.VideoKey]
machine.Video
= Array.ConvertAll(item.Video, ConvertToInternalModel);
}
if (item.Sound is not null)
machine[Data.Models.Metadata.Machine.SoundKey] = ConvertToInternalModel(item.Sound);
machine.Sound = ConvertToInternalModel(item.Sound);
if (item.Input is not null)
machine[Data.Models.Metadata.Machine.InputKey] = ConvertToInternalModel(item.Input);
machine.Input = ConvertToInternalModel(item.Input);
if (item.DipSwitch is not null && item.DipSwitch.Length > 0)
{
machine[Data.Models.Metadata.Machine.DipSwitchKey]
machine.DipSwitch
= Array.ConvertAll(item.DipSwitch, ConvertToInternalModel);
}
if (item.Configuration is not null && item.Configuration.Length > 0)
{
machine[Data.Models.Metadata.Machine.ConfigurationKey]
machine.Configuration
= Array.ConvertAll(item.Configuration, ConvertToInternalModel);
}
if (item.Port is not null && item.Port.Length > 0)
{
machine[Data.Models.Metadata.Machine.PortKey]
machine.Port
= Array.ConvertAll(item.Port, ConvertToInternalModel);
}
if (item.Adjuster is not null && item.Adjuster.Length > 0)
{
machine[Data.Models.Metadata.Machine.AdjusterKey]
machine.Adjuster
= Array.ConvertAll(item.Adjuster, ConvertToInternalModel);
}
if (item.Driver is not null)
machine[Data.Models.Metadata.Machine.DriverKey] = ConvertToInternalModel(item.Driver);
machine.Driver = ConvertToInternalModel(item.Driver);
if (item.Feature is not null && item.Feature.Length > 0)
{
machine[Data.Models.Metadata.Machine.FeatureKey]
machine.Feature
= Array.ConvertAll(item.Feature, ConvertToInternalModel);
}
if (item.Device is not null && item.Device.Length > 0)
{
machine[Data.Models.Metadata.Machine.DeviceKey]
machine.Device
= Array.ConvertAll(item.Device, ConvertToInternalModel);
}
if (item.Slot is not null && item.Slot.Length > 0)
{
machine[Data.Models.Metadata.Machine.SlotKey]
machine.Slot
= Array.ConvertAll(item.Slot, ConvertToInternalModel);
}
if (item.SoftwareList is not null && item.SoftwareList.Length > 0)
{
machine[Data.Models.Metadata.Machine.SoftwareListKey]
machine.SoftwareList
= Array.ConvertAll(item.SoftwareList, ConvertToInternalModel);
}
if (item.RamOption is not null && item.RamOption.Length > 0)
{
machine[Data.Models.Metadata.Machine.RamOptionKey]
machine.RamOption
= Array.ConvertAll(item.RamOption, ConvertToInternalModel);
}

20
SabreTools.Serialization.CrossModel/Logiqx.Deserializer.cs
View File

@@ -144,43 +144,43 @@ namespace SabreTools.Serialization.CrossModel
if (trurip is not null)
gameBase.Trurip = trurip;
var releases = item.Read<Data.Models.Metadata.Release[]>(Data.Models.Metadata.Machine.ReleaseKey);
var releases = item.Release;
if (releases is not null && releases.Length > 0)
gameBase.Release = Array.ConvertAll(releases, ConvertFromInternalModel);
var biosSets = item.Read<Data.Models.Metadata.BiosSet[]>(Data.Models.Metadata.Machine.BiosSetKey);
var biosSets = item.BiosSet;
if (biosSets is not null && biosSets.Length > 0)
gameBase.BiosSet = Array.ConvertAll(biosSets, ConvertFromInternalModel);
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is not null && roms.Length > 0)
gameBase.Rom = Array.ConvertAll(roms, ConvertFromInternalModel);
var disks = item.Read<Data.Models.Metadata.Disk[]>(Data.Models.Metadata.Machine.DiskKey);
var disks = item.Disk;
if (disks is not null && disks.Length > 0)
gameBase.Disk = Array.ConvertAll(disks, ConvertFromInternalModel);
var medias = item.Read<Data.Models.Metadata.Media[]>(Data.Models.Metadata.Machine.MediaKey);
var medias = item.Media;
if (medias is not null && medias.Length > 0)
gameBase.Media = Array.ConvertAll(medias, ConvertFromInternalModel);
var deviceRefs = item.Read<Data.Models.Metadata.DeviceRef[]>(Data.Models.Metadata.Machine.DeviceRefKey);
var deviceRefs = item.DeviceRef;
if (deviceRefs is not null && deviceRefs.Length > 0)
gameBase.DeviceRef = Array.ConvertAll(deviceRefs, ConvertFromInternalModel);
var samples = item.Read<Data.Models.Metadata.Sample[]>(Data.Models.Metadata.Machine.SampleKey);
var samples = item.Sample;
if (samples is not null && samples.Length > 0)
gameBase.Sample = Array.ConvertAll(samples, ConvertFromInternalModel);
var archives = item.Read<Data.Models.Metadata.Archive[]>(Data.Models.Metadata.Machine.ArchiveKey);
var archives = item.Archive;
if (archives is not null && archives.Length > 0)
gameBase.Archive = Array.ConvertAll(archives, ConvertFromInternalModel);
var driver = item.Read<Data.Models.Metadata.Driver>(Data.Models.Metadata.Machine.DriverKey);
var driver = item.Driver;
if (driver is not null)
gameBase.Driver = ConvertFromInternalModel(driver);
var softwareLists = item.Read<Data.Models.Metadata.SoftwareList[]>(Data.Models.Metadata.Machine.SoftwareListKey);
var softwareLists = item.SoftwareList;
if (softwareLists is not null && softwareLists.Length > 0)
gameBase.SoftwareList = Array.ConvertAll(softwareLists, ConvertFromInternalModel);

20
SabreTools.Serialization.CrossModel/Logiqx.Serializer.cs
View File

@@ -149,34 +149,34 @@ namespace SabreTools.Serialization.CrossModel
};
if (item.Release is not null && item.Release.Length > 0)
machine[Data.Models.Metadata.Machine.ReleaseKey] = Array.ConvertAll(item.Release, ConvertToInternalModel);
machine.Release = Array.ConvertAll(item.Release, ConvertToInternalModel);
if (item.BiosSet is not null && item.BiosSet.Length > 0)
machine[Data.Models.Metadata.Machine.BiosSetKey] = Array.ConvertAll(item.BiosSet, ConvertToInternalModel);
machine.BiosSet = Array.ConvertAll(item.BiosSet, ConvertToInternalModel);
if (item.Rom is not null && item.Rom.Length > 0)
machine[Data.Models.Metadata.Machine.RomKey] = Array.ConvertAll(item.Rom, ConvertToInternalModel);
machine.Rom = Array.ConvertAll(item.Rom, ConvertToInternalModel);
if (item.Disk is not null && item.Disk.Length > 0)
machine[Data.Models.Metadata.Machine.DiskKey] = Array.ConvertAll(item.Disk, ConvertToInternalModel);
machine.Disk = Array.ConvertAll(item.Disk, ConvertToInternalModel);
if (item.Media is not null && item.Media.Length > 0)
machine[Data.Models.Metadata.Machine.MediaKey] = Array.ConvertAll(item.Media, ConvertToInternalModel);
machine.Media = Array.ConvertAll(item.Media, ConvertToInternalModel);
if (item.DeviceRef is not null && item.DeviceRef.Length > 0)
machine[Data.Models.Metadata.Machine.DeviceRefKey] = Array.ConvertAll(item.DeviceRef, ConvertToInternalModel);
machine.DeviceRef = Array.ConvertAll(item.DeviceRef, ConvertToInternalModel);
if (item.Sample is not null && item.Sample.Length > 0)
machine[Data.Models.Metadata.Machine.SampleKey] = Array.ConvertAll(item.Sample, ConvertToInternalModel);
machine.Sample = Array.ConvertAll(item.Sample, ConvertToInternalModel);
if (item.Archive is not null && item.Archive.Length > 0)
machine[Data.Models.Metadata.Machine.ArchiveKey] = Array.ConvertAll(item.Archive, ConvertToInternalModel);
machine.Archive = Array.ConvertAll(item.Archive, ConvertToInternalModel);
if (item.Driver is not null)
machine[Data.Models.Metadata.Machine.DriverKey] = ConvertToInternalModel(item.Driver);
machine.Driver = ConvertToInternalModel(item.Driver);
if (item.SoftwareList is not null && item.SoftwareList.Length > 0)
machine[Data.Models.Metadata.Machine.SoftwareListKey] = Array.ConvertAll(item.SoftwareList, ConvertToInternalModel);
machine.SoftwareList = Array.ConvertAll(item.SoftwareList, ConvertToInternalModel);
return machine;
}

2
SabreTools.Serialization.CrossModel/OfflineList.Deserializer.cs
View File

@@ -96,7 +96,7 @@ namespace SabreTools.Serialization.CrossModel
DuplicateID = item.DuplicateID,
};
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is not null && roms.Length > 0)
{
var romSizes = Array.ConvertAll(roms, r => r.Size ?? -1);

2
SabreTools.Serialization.CrossModel/OfflineList.Serializer.cs
View File

@@ -81,7 +81,7 @@ namespace SabreTools.Serialization.CrossModel
if (item.Files?.RomCRC is not null && item.Files.RomCRC.Length > 0)
{
machine[Data.Models.Metadata.Machine.RomKey]
machine.Rom
= Array.ConvertAll(item.Files.RomCRC, romCRC =>
{
var rom = ConvertToInternalModel(romCRC);

2
SabreTools.Serialization.CrossModel/OpenMSX.Deserializer.cs
View File

@@ -48,7 +48,7 @@ namespace SabreTools.Serialization.CrossModel
Country = item.Country,
};
var dumps = item.Read<Data.Models.Metadata.Dump[]>(Data.Models.Metadata.Machine.DumpKey);
var dumps = item.Dump;
if (dumps is not null && dumps.Length > 0)
game.Dump = Array.ConvertAll(dumps, ConvertFromInternalModel);

2
SabreTools.Serialization.CrossModel/OpenMSX.Serializer.cs
View File

@@ -54,7 +54,7 @@ namespace SabreTools.Serialization.CrossModel
if (item.Dump is not null && item.Dump.Length > 0)
{
machine[Data.Models.Metadata.Machine.DumpKey]
machine.Dump
= Array.ConvertAll(item.Dump, ConvertToInternalModel);
}

2
SabreTools.Serialization.CrossModel/RomCenter.Deserializer.cs
View File

@@ -84,7 +84,7 @@ namespace SabreTools.Serialization.CrossModel
/// </summary>
private static Rom[] ConvertMachineFromInternalModel(Data.Models.Metadata.Machine item)
{
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is null)
return [];

4
SabreTools.Serialization.CrossModel/RomCenter.Serializer.cs
View File

@@ -72,10 +72,10 @@ namespace SabreTools.Serialization.CrossModel
{
RomOf = item.RomOf,
CloneOf = item.ParentName,
//[Data.Models.Metadata.Machine.ParentDescriptionKey] = item.ParentDescription, // This is unmappable
//.ParentDescription = item.ParentDescription, // This is unmappable
Name = item.GameName,
Description = item.GameDescription,
[Data.Models.Metadata.Machine.RomKey] = new Data.Models.Metadata.Rom[] { ConvertToInternalModel(item) },
Rom = new Data.Models.Metadata.Rom[] { ConvertToInternalModel(item) },
};
return machine;

6
SabreTools.Serialization.CrossModel/SeparatedValue.Deserializer.cs
View File

@@ -45,21 +45,21 @@ namespace SabreTools.Serialization.CrossModel
{
var rowItems = new List<Row>();
var roms = item.Read<Data.Models.Metadata.Rom[]>(Data.Models.Metadata.Machine.RomKey);
var roms = item.Rom;
if (roms is not null && roms.Length > 0)
{
rowItems.AddRange(
Array.ConvertAll(roms, r => ConvertFromInternalModel(r, item, header)));
}
var disks = item.Read<Data.Models.Metadata.Disk[]>(Data.Models.Metadata.Machine.DiskKey);
var disks = item.Disk;
if (disks is not null && disks.Length > 0)
{
rowItems.AddRange(
Array.ConvertAll(disks, d => ConvertFromInternalModel(d, item, header)));
}
var media = item.Read<Data.Models.Metadata.Media[]>(Data.Models.Metadata.Machine.MediaKey);
var media = item.Media;
if (media is not null && media.Length > 0)
{
rowItems.AddRange(

6
SabreTools.Serialization.CrossModel/SeparatedValue.Serializer.cs
View File

@@ -61,15 +61,15 @@ namespace SabreTools.Serialization.CrossModel
switch (datItem)
{
case Data.Models.Metadata.Disk disk:
machine[Data.Models.Metadata.Machine.DiskKey] = new Data.Models.Metadata.Disk[] { disk };
machine.Disk = new Data.Models.Metadata.Disk[] { disk };
break;
case Data.Models.Metadata.Media media:
machine[Data.Models.Metadata.Machine.MediaKey] = new Data.Models.Metadata.Media[] { media };
machine.Media = new Data.Models.Metadata.Media[] { media };
break;
case Data.Models.Metadata.Rom rom:
machine[Data.Models.Metadata.Machine.RomKey] = new Data.Models.Metadata.Rom[] { rom };
machine.Rom = new Data.Models.Metadata.Rom[] { rom };
break;
default:

6
SabreTools.Serialization.CrossModel/SoftwareList.Deserializer.cs
View File

@@ -51,15 +51,15 @@ namespace SabreTools.Serialization.CrossModel
Notes = item.Notes,
};
var infos = item.Read<Data.Models.Metadata.Info[]>(Data.Models.Metadata.Machine.InfoKey);
var infos = item.Info;
if (infos is not null && infos.Length > 0)
software.Info = Array.ConvertAll(infos, ConvertFromInternalModel);
var sharedFeats = item.Read<Data.Models.Metadata.SharedFeat[]>(Data.Models.Metadata.Machine.SharedFeatKey);
var sharedFeats = item.SharedFeat;
if (sharedFeats is not null && sharedFeats.Length > 0)
software.SharedFeat = Array.ConvertAll(sharedFeats, ConvertFromInternalModel);
var parts = item.Read<Data.Models.Metadata.Part[]>(Data.Models.Metadata.Machine.PartKey);
var parts = item.Part;
if (parts is not null && parts.Length > 0)
software.Part = Array.ConvertAll(parts, ConvertFromInternalModel);

6
SabreTools.Serialization.CrossModel/SoftwareList.Serializer.cs
View File

@@ -56,13 +56,13 @@ namespace SabreTools.Serialization.CrossModel
};
if (item.Info is not null && item.Info.Length > 0)
machine[Data.Models.Metadata.Machine.InfoKey] = Array.ConvertAll(item.Info, ConvertToInternalModel);
machine.Info = Array.ConvertAll(item.Info, ConvertToInternalModel);
if (item.SharedFeat is not null && item.SharedFeat.Length > 0)
machine[Data.Models.Metadata.Machine.SharedFeatKey] = Array.ConvertAll(item.SharedFeat, ConvertToInternalModel);
machine.SharedFeat = Array.ConvertAll(item.SharedFeat, ConvertToInternalModel);
if (item.Part is not null && item.Part.Length > 0)
machine[Data.Models.Metadata.Machine.PartKey] = Array.ConvertAll(item.Part, ConvertToInternalModel);
machine.Part = Array.ConvertAll(item.Part, ConvertToInternalModel);
return machine;
}