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
Files
e8069271956099b32183531b57cc43e069b17ccc
SabreTools/SabreTools.Core/Converters.cs

3408 lines
114 KiB
C#
Raw Normal View History

Clean up more info instances
2020-09-18 01:50:44 -07:00
using System.Collections.Generic;
using System.Text.RegularExpressions;
Reduce redundant code
2020-08-28 22:21:35 -07:00
Data and Tools -> Core
2020-12-08 13:23:59 -08:00
namespace SabreTools.Core
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
{
public static class Converters
{
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
#region Enum to Enum
/// <summary>
/// Get the field associated with each hash type
/// </summary>
public static Field AsField(this Hash hash)
{
switch (hash)
{
case Hash.CRC:
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_CRC;
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
case Hash.MD5:
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_MD5;
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
#if NET_FRAMEWORK
case Hash.RIPEMD160:
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_RIPEMD160;
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
#endif
case Hash.SHA1:
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_SHA1;
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
case Hash.SHA256:
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_SHA256;
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
case Hash.SHA384:
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_SHA384;
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
case Hash.SHA512:
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_SHA512;
Add and use SpamSum for Media and Rom types SpamSum implementation courtesy of https://github.com/aaru-dps/Aaru
2020-09-04 15:02:15 -07:00
case Hash.SpamSum:
return Field.DatItem_SpamSum;
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
default:
return Field.NULL;
}
}
Clean up more info instances
2020-09-18 01:50:44 -07:00
/// <summary>
/// Get the fields associated with each hash type
/// </summary>
public static List<Field> AsFields(this Hash hash)
{
List<Field> fields = new List<Field>();
if (hash.HasFlag(Hash.CRC))
fields.Add(Field.DatItem_CRC);
if (hash.HasFlag(Hash.MD5))
fields.Add(Field.DatItem_MD5);
#if NET_FRAMEWORK
if (hash.HasFlag(Hash.RIPEMD160))
fields.Add(Field.DatItem_RIPEMD160);
#endif
if (hash.HasFlag(Hash.SHA1))
fields.Add(Field.DatItem_SHA1);
if (hash.HasFlag(Hash.SHA256))
fields.Add(Field.DatItem_SHA256);
if (hash.HasFlag(Hash.SHA384))
fields.Add(Field.DatItem_SHA384);
if (hash.HasFlag(Hash.SHA512))
fields.Add(Field.DatItem_SHA512);
if (hash.HasFlag(Hash.SpamSum))
fields.Add(Field.DatItem_SpamSum);
return fields;
}
Reduce redundant code
2020-08-28 22:21:35 -07:00
/// <summary>
/// Get the default OutputFormat associated with each PackingFlag
/// </summary>
/// <param name="packing"></param>
/// <returns></returns>
public static OutputFormat AsOutputFormat(this PackingFlag packing)
{
switch (packing)
{
case PackingFlag.Zip:
return OutputFormat.TorrentZip;
case PackingFlag.Unzip:
case PackingFlag.Partial:
return OutputFormat.Folder;
case PackingFlag.Flat:
return OutputFormat.ParentFolder;
case PackingFlag.None:
default:
return OutputFormat.Folder;
}
}
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
#endregion
#region String to Enum
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
/// <summary>
/// Get ChipType value from input string
/// </summary>
/// <param name="chipType">String to get value from</param>
/// <returns>ChipType value corresponding to the string</returns>
public static ChipType AsChipType(this string chipType)
{
#if NET_FRAMEWORK
switch (chipType?.ToLowerInvariant())
{
case "cpu":
return ChipType.CPU;
case "audio":
return ChipType.Audio;
default:
return ChipType.NULL;
}
#else
return chipType?.ToLowerInvariant() switch
{
"cpu" => ChipType.CPU,
"audio" => ChipType.Audio,
_ => ChipType.NULL,
};
#endif
}
Add ControlType, fix a bunch of numerics
2020-09-06 23:00:13 -07:00
/// <summary>
/// Get ControlType value from input string
/// </summary>
/// <param name="controlType">String to get value from</param>
/// <returns>ControlType value corresponding to the string</returns>
public static ControlType AsControlType(this string controlType)
{
#if NET_FRAMEWORK
switch (controlType?.ToLowerInvariant())
{
case "joy":
return ControlType.Joy;
case "stick":
return ControlType.Stick;
case "paddle":
return ControlType.Paddle;
case "pedal":
return ControlType.Pedal;
case "lightgun":
return ControlType.Lightgun;
case "positional":
return ControlType.Positional;
case "dial":
return ControlType.Dial;
case "trackball":
return ControlType.Trackball;
case "mouse":
return ControlType.Mouse;
case "only_buttons":
return ControlType.OnlyButtons;
case "keypad":
return ControlType.Keypad;
case "keyboard":
return ControlType.Keyboard;
case "mahjong":
return ControlType.Mahjong;
case "hanafuda":
return ControlType.Hanafuda;
case "gambling":
return ControlType.Gambling;
default:
return ControlType.NULL;
}
#else
return controlType?.ToLowerInvariant() switch
{
"joy" => ControlType.Joy,
"stick" => ControlType.Stick,
"paddle" => ControlType.Paddle,
"pedal" => ControlType.Pedal,
"lightgun" => ControlType.Lightgun,
"positional" => ControlType.Positional,
"dial" => ControlType.Dial,
"trackball" => ControlType.Trackball,
"mouse" => ControlType.Mouse,
"only_buttons" => ControlType.OnlyButtons,
"keypad" => ControlType.Keypad,
"keyboard" => ControlType.Keyboard,
"mahjong" => ControlType.Mahjong,
"hanafuda" => ControlType.Hanafuda,
"gambling" => ControlType.Gambling,
_ => ControlType.NULL,
};
#endif
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
/// <summary>
/// Get DatFormat value from input string
/// </summary>
/// <param name="input">String to get value from</param>
/// <returns>DatFormat value corresponding to the string</returns>
public static DatFormat AsDatFormat(this string input)
{
switch (input?.Trim().ToLowerInvariant())
{
case "all":
return DatFormat.ALL;
case "am":
case "attractmode":
return DatFormat.AttractMode;
case "cmp":
case "clrmamepro":
return DatFormat.ClrMamePro;
case "csv":
return DatFormat.CSV;
case "dc":
case "doscenter":
return DatFormat.DOSCenter;
Typos and such
2020-09-05 23:15:48 -07:00
case "everdrive":
case "smdb":
return DatFormat.EverdriveSMDB;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "json":
Better shorthand, change internal naming
2020-09-07 22:57:44 -07:00
case "sj":
case "sabrejson":
New name please
2020-09-07 22:40:27 -07:00
return DatFormat.SabreJSON;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "lr":
case "listrom":
return DatFormat.Listrom;
case "lx":
case "listxml":
return DatFormat.Listxml;
case "md5":
return DatFormat.RedumpMD5;
case "miss":
case "missfile":
return DatFormat.MissFile;
case "msx":
case "openmsx":
return DatFormat.OpenMSX;
case "ol":
case "offlinelist":
return DatFormat.OfflineList;
case "rc":
case "romcenter":
return DatFormat.RomCenter;
#if NET_FRAMEWORK
case "ripemd160":
return DatFormat.RedumpRIPEMD160;
#endif
case "sd":
case "sabredat":
Better shorthand, change internal naming
2020-09-07 22:57:44 -07:00
case "sx":
case "sabrexml":
return DatFormat.SabreXML;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "sfv":
return DatFormat.RedumpSFV;
case "sha1":
return DatFormat.RedumpSHA1;
case "sha256":
return DatFormat.RedumpSHA256;
case "sha384":
return DatFormat.RedumpSHA384;
case "sha512":
return DatFormat.RedumpSHA512;
case "sl":
case "softwarelist":
return DatFormat.SoftwareList;
Add and use SpamSum for Media and Rom types SpamSum implementation courtesy of https://github.com/aaru-dps/Aaru
2020-09-04 15:02:15 -07:00
case "spamsum":
return DatFormat.RedumpSpamSum;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "ssv":
return DatFormat.SSV;
case "tsv":
return DatFormat.TSV;
case "xml":
case "logiqx":
return DatFormat.Logiqx;
default:
return 0x0;
}
}
Add and use DeviceType
2020-09-07 00:39:59 -07:00
/// <summary>
/// Get DeviceType value from input string
/// </summary>
/// <param name="deviceType">String to get value from</param>
/// <returns>DeviceType value corresponding to the string</returns>
public static DeviceType AsDeviceType(this string deviceType)
{
#if NET_FRAMEWORK
switch (deviceType?.ToLowerInvariant())
{
case "unknown":
return DeviceType.Unknown;
case "cartridge":
return DeviceType.Cartridge;
case "floppydisk":
return DeviceType.FloppyDisk;
case "harddisk":
return DeviceType.HardDisk;
case "cylinder":
return DeviceType.Cylinder;
case "cassette":
return DeviceType.Cassette;
case "punchcard":
return DeviceType.PunchCard;
case "punchtape":
return DeviceType.PunchTape;
case "printout":
return DeviceType.Printout;
case "serial":
return DeviceType.Serial;
case "parallel":
return DeviceType.Parallel;
case "snapshot":
return DeviceType.Snapshot;
case "quickload":
return DeviceType.QuickLoad;
case "memcard":
return DeviceType.MemCard;
case "cdrom":
return DeviceType.CDROM;
case "magtape":
return DeviceType.MagTape;
case "romimage":
return DeviceType.ROMImage;
case "midiin":
return DeviceType.MIDIIn;
case "midiout":
return DeviceType.MIDIOut;
case "picture":
return DeviceType.Picture;
case "vidfile":
return DeviceType.VidFile;
default:
return DeviceType.NULL;
}
#else
return deviceType?.ToLowerInvariant() switch
{
"unknown" => DeviceType.Unknown,
"cartridge" => DeviceType.Cartridge,
"floppydisk" => DeviceType.FloppyDisk,
"harddisk" => DeviceType.HardDisk,
"cylinder" => DeviceType.Cylinder,
"cassette" => DeviceType.Cassette,
"punchcard" => DeviceType.PunchCard,
"punchtape" => DeviceType.PunchTape,
"printout" => DeviceType.Printout,
"serial" => DeviceType.Serial,
"parallel" => DeviceType.Parallel,
"snapshot" => DeviceType.Snapshot,
"quickload" => DeviceType.QuickLoad,
"memcard" => DeviceType.MemCard,
"cdrom" => DeviceType.CDROM,
"magtape" => DeviceType.MagTape,
"romimage" => DeviceType.ROMImage,
"midiin" => DeviceType.MIDIIn,
"midiout" => DeviceType.MIDIOut,
"picture" => DeviceType.Picture,
"vidfile" => DeviceType.VidFile,
_ => DeviceType.NULL,
};
#endif
}
Create and use DisplayType, LoadFlag enums
2020-09-03 21:32:00 -07:00
/// <summary>
/// Get DisplayType value from input string
/// </summary>
/// <param name="displayType">String to get value from</param>
/// <returns>DisplayType value corresponding to the string</returns>
public static DisplayType AsDisplayType(this string displayType)
{
#if NET_FRAMEWORK
switch (displayType?.ToLowerInvariant())
{
case "raster":
return DisplayType.Raster;
case "vector":
return DisplayType.Vector;
case "lcd":
return DisplayType.LCD;
case "svg":
return DisplayType.SVG;
case "unknown":
return DisplayType.Unknown;
default:
return DisplayType.NULL;
}
#else
return displayType?.ToLowerInvariant() switch
{
"raster" => DisplayType.Raster,
"vector" => DisplayType.Vector,
"lcd" => DisplayType.LCD,
"svg" => DisplayType.SVG,
"unknown" => DisplayType.Unknown,
_ => DisplayType.NULL,
};
#endif
}
Add and use Endianness enum
2020-09-03 21:39:16 -07:00
/// <summary>
/// Get Endianness value from input string
/// </summary>
/// <param name="endianness">String to get value from</param>
/// <returns>Endianness value corresponding to the string</returns>
public static Endianness AsEndianness(this string endianness)
{
#if NET_FRAMEWORK
switch (endianness?.ToLowerInvariant())
{
case "big":
return Endianness.Big;
case "little":
return Endianness.Little;
default:
return Endianness.NULL;
}
#else
return endianness?.ToLowerInvariant() switch
{
"big" => Endianness.Big,
"little" => Endianness.Little,
_ => Endianness.NULL,
};
#endif
}
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
/// <summary>
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
/// Get FeatureStatus value from input string
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
/// </summary>
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
/// <param name="featureStatus">String to get value from</param>
/// <returns>FeatureStatus value corresponding to the string</returns>
public static FeatureStatus AsFeatureStatus(this string featureStatus)
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
{
#if NET_FRAMEWORK
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
switch (featureStatus?.ToLowerInvariant())
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
{
case "unemulated":
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
return FeatureStatus.Unemulated;
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
case "imperfect":
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
return FeatureStatus.Imperfect;
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
default:
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
return FeatureStatus.NULL;
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
}
#else
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
return featureStatus?.ToLowerInvariant() switch
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
{
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
"unemulated" => FeatureStatus.Unemulated,
"imperfect" => FeatureStatus.Imperfect,
_ => FeatureStatus.NULL,
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
};
#endif
}
Create and use DatItems.FeatureType
2020-09-02 14:04:02 -07:00
/// <summary>
/// Get FeatureType value from input string
/// </summary>
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
/// <param name="emulationStatus">String to get value from</param>
Create and use DatItems.FeatureType
2020-09-02 14:04:02 -07:00
/// <returns>FeatureType value corresponding to the string</returns>
public static FeatureType AsFeatureType(this string featureType)
{
#if NET_FRAMEWORK
switch (featureType?.ToLowerInvariant())
{
case "protection":
return FeatureType.Protection;
case "palette":
return FeatureType.Palette;
case "graphics":
return FeatureType.Graphics;
case "sound":
return FeatureType.Sound;
case "controls":
return FeatureType.Controls;
case "keyboard":
return FeatureType.Keyboard;
case "mouse":
return FeatureType.Mouse;
case "microphone":
return FeatureType.Microphone;
case "camera":
return FeatureType.Camera;
case "disk":
return FeatureType.Disk;
case "printer":
return FeatureType.Printer;
case "lan":
return FeatureType.Lan;
case "wan":
return FeatureType.Wan;
case "timing":
return FeatureType.Timing;
default:
return FeatureType.NULL;
}
#else
return featureType?.ToLowerInvariant() switch
{
"protection" => FeatureType.Protection,
"palette" => FeatureType.Palette,
"graphics" => FeatureType.Graphics,
"sound" => FeatureType.Sound,
"controls" => FeatureType.Controls,
"keyboard" => FeatureType.Keyboard,
"mouse" => FeatureType.Mouse,
"microphone" => FeatureType.Microphone,
"camera" => FeatureType.Camera,
"disk" => FeatureType.Disk,
"printer" => FeatureType.Printer,
"lan" => FeatureType.Lan,
"wan" => FeatureType.Wan,
"timing" => FeatureType.Timing,
_ => FeatureType.NULL,
};
#endif
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
/// <summary>
/// Get Field value from input string
/// </summary>
/// <param name="input">String to get value from</param>
/// <returns>Field value corresponding to the string</returns>
public static Field AsField(this string input)
{
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
// If the input is null, we return null
if (input == null)
return Field.NULL;
// Normalize the input
input = input.ToLowerInvariant();
// Create regex strings
Perf improvements, fix regex
2020-09-02 00:24:46 -07:00
string headerRegex = @"^(dat|header|datheader)[.\-_\s]";
string machineRegex = @"^(game|machine)[.\-_\s]";
string datItemRegex = @"^(item|datitem)[.\-_\s]";
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
// If we have a header field
if (Regex.IsMatch(input, headerRegex))
{
// Replace the match and re-normalize
string headerInput = Regex.Replace(input, headerRegex, string.Empty)
.Replace(' ', '_')
.Replace('-', '_')
.Replace('.', '_');
switch (headerInput)
{
#region Common
case "file":
case "filename":
case "file_name":
return Field.DatHeader_FileName;
case "dat":
case "datname":
case "dat_name":
case "internalname":
case "internal_name":
return Field.DatHeader_Name;
case "desc":
case "description":
return Field.DatHeader_Description;
case "root":
case "rootdir":
case "root_dir":
case "rootdirectory":
case "root_directory":
return Field.DatHeader_RootDir;
case "category":
return Field.DatHeader_Category;
case "version":
return Field.DatHeader_Version;
case "date":
case "timestamp":
case "time_stamp":
return Field.DatHeader_Date;
case "author":
return Field.DatHeader_Author;
case "email":
case "e_mail":
return Field.DatHeader_Email;
case "homepage":
case "home_page":
return Field.DatHeader_Homepage;
case "url":
return Field.DatHeader_Url;
case "comment":
return Field.DatHeader_Comment;
case "header":
case "headerskipper":
case "header_skipper":
case "skipper":
return Field.DatHeader_HeaderSkipper;
case "dattype":
case "type":
case "superdat":
return Field.DatHeader_Type;
case "forcemerging":
case "force_merging":
return Field.DatHeader_ForceMerging;
case "forcenodump":
case "force_nodump":
return Field.DatHeader_ForceNodump;
case "forcepacking":
case "force_packing":
return Field.DatHeader_ForcePacking;
#endregion
#region ListXML
case "debug":
return Field.DatHeader_Debug;
case "mameconfig":
case "mame_config":
return Field.DatHeader_MameConfig;
#endregion
#region Logiqx
case "build":
return Field.DatHeader_Build;
case "rommode":
case "rom_mode":
return Field.DatHeader_RomMode;
case "biosmode":
case "bios_mode":
return Field.DatHeader_BiosMode;
case "samplemode":
case "sample_mode":
return Field.DatHeader_SampleMode;
case "lockrommode":
case "lockrom_mode":
case "lock_rommode":
case "lock_rom_mode":
return Field.DatHeader_LockRomMode;
case "lockbiosmode":
case "lockbios_mode":
case "lock_biosmode":
case "lock_bios_mode":
return Field.DatHeader_LockBiosMode;
case "locksamplemode":
case "locksample_mode":
case "lock_samplemode":
case "lock_sample_mode":
return Field.DatHeader_LockSampleMode;
#endregion
#region OfflineList
case "system":
case "plugin": // Used with RomCenter
return Field.DatHeader_System;
case "screenshotwidth":
case "screenshotswidth":
case "screenshot_width":
case "screenshots_width":
return Field.DatHeader_ScreenshotsWidth;
case "screenshotheight":
case "screenshotsheight":
case "screenshot_height":
case "screenshots_height":
return Field.DatHeader_ScreenshotsHeight;
case "info_name":
case "infos_name":
return Field.DatHeader_Info_Name;
case "info_visible":
case "infos_visible":
return Field.DatHeader_Info_Visible;
case "info_isnamingoption":
case "info_is_naming_option":
case "infos_isnamingoption":
case "infos_is_naming_option":
return Field.DatHeader_Info_IsNamingOption;
case "info_default":
case "infos_default":
return Field.DatHeader_Info_Default;
case "canopen":
case "can_open":
return Field.DatHeader_CanOpen;
case "romtitle":
case "rom_title":
return Field.DatHeader_RomTitle;
#endregion
#region RomCenter
case "rcversion":
case "rc_version":
case "romcenterversion":
case "romcenter_version":
case "rom_center_version":
return Field.DatHeader_RomCenterVersion;
#endregion
}
}
// If we have a machine field
else if (Regex.IsMatch(input, machineRegex))
{
// Replace the match and re-normalize
string machineInput = Regex.Replace(input, machineRegex, string.Empty)
.Replace(' ', '_')
.Replace('-', '_')
.Replace('.', '_');
switch (machineInput)
{
#region Common
case "name":
return Field.Machine_Name;
case "comment":
case "extra": // Used with AttractMode
return Field.Machine_Comment;
case "desc":
case "description":
return Field.Machine_Description;
case "year":
return Field.Machine_Year;
case "manufacturer":
return Field.Machine_Manufacturer;
case "publisher":
return Field.Machine_Publisher;
case "category":
return Field.Machine_Category;
case "romof":
case "rom_of":
return Field.Machine_RomOf;
case "cloneof":
case "clone_of":
return Field.Machine_CloneOf;
case "sampleof":
case "sample_of":
return Field.Machine_SampleOf;
case "type":
return Field.Machine_Type;
#endregion
#region AttractMode
case "players":
return Field.Machine_Players;
case "rotation":
return Field.Machine_Rotation;
case "control":
return Field.Machine_Control;
case "amstatus":
case "am_status":
case "gamestatus":
case "supportstatus":
case "support_status":
return Field.Machine_Status;
case "displaycount":
return Field.Machine_DisplayCount;
case "displaytype":
return Field.Machine_DisplayType;
case "buttons":
return Field.Machine_Buttons;
#endregion
#region ListXML
case "sourcefile":
case "source_file":
return Field.Machine_SourceFile;
case "runnable":
Promote Input
2020-09-02 21:59:26 -07:00
return Field.Machine_Runnable;
Finish string -> Field
2020-08-25 12:15:28 -07:00
#endregion
#region Logiqx
case "board":
return Field.Machine_Board;
case "rebuildto":
case "rebuild_to":
return Field.Machine_RebuildTo;
#endregion
#region Logiqx EmuArc
case "titleid":
case "title_id":
return Field.Machine_TitleID;
case "developer":
return Field.Machine_Developer;
case "genre":
return Field.Machine_Genre;
case "subgenre":
case "sub_genre":
return Field.Machine_Subgenre;
case "ratings":
return Field.Machine_Ratings;
case "score":
return Field.Machine_Score;
case "enabled":
return Field.Machine_Enabled;
case "crc":
case "hascrc":
case "has_crc":
return Field.Machine_CRC;
case "relatedto":
case "related_to":
return Field.Machine_RelatedTo;
#endregion
#region OpenMSX
case "genmsxid":
case "genmsx_id":
case "gen_msxid":
case "gen_msx_id":
return Field.Machine_GenMSXID;
case "system":
case "msxsystem":
case "msx_system":
return Field.Machine_System;
case "country":
return Field.Machine_Country;
#endregion
#region SoftwareList
case "supported":
return Field.Machine_Supported;
#endregion
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
}
}
// If we have a datitem field
else if (Regex.IsMatch(input, datItemRegex))
{
// Replace the match and re-normalize
string itemInput = Regex.Replace(input, datItemRegex, string.Empty)
.Replace(' ', '_')
.Replace('-', '_')
.Replace('.', '_');
switch (itemInput)
{
#region Common
Finish string -> Field
2020-08-25 12:15:28 -07:00
case "type":
return Field.DatItem_Type;
#endregion
#region Item-Specific
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
#region Actionable
Finish string -> Field
2020-08-25 12:15:28 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
// Rom
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "name":
return Field.DatItem_Name;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "bios":
return Field.DatItem_Bios;
Chip gets a promotion
2020-08-25 22:48:46 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "size":
return Field.DatItem_Size;
Chip gets a promotion
2020-08-25 22:48:46 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "crc":
case "crc32":
return Field.DatItem_CRC;
Chip gets a promotion
2020-08-25 22:48:46 -07:00
Finish string -> Field
2020-08-25 12:15:28 -07:00
case "md5":
case "md5_hash":
return Field.DatItem_MD5;
Chip gets a promotion
2020-08-25 22:48:46 -07:00
Finish string -> Field
2020-08-25 12:15:28 -07:00
#if NET_FRAMEWORK
case "ripemd160":
case "ripemd160_hash":
return Field.DatItem_RIPEMD160;
#endif
Chip gets a promotion
2020-08-25 22:48:46 -07:00
Finish string -> Field
2020-08-25 12:15:28 -07:00
case "sha1":
case "sha_1":
case "sha1hash":
case "sha1_hash":
case "sha_1hash":
case "sha_1_hash":
return Field.DatItem_SHA1;
case "sha256":
case "sha_256":
case "sha256hash":
case "sha256_hash":
case "sha_256hash":
case "sha_256_hash":
return Field.DatItem_SHA256;
case "sha384":
case "sha_384":
case "sha384hash":
case "sha384_hash":
case "sha_384hash":
case "sha_384_hash":
return Field.DatItem_SHA384;
case "sha512":
case "sha_512":
case "sha512hash":
case "sha512_hash":
case "sha_512hash":
case "sha_512_hash":
return Field.DatItem_SHA512;
Add and use SpamSum for Media and Rom types SpamSum implementation courtesy of https://github.com/aaru-dps/Aaru
2020-09-04 15:02:15 -07:00
case "spamsum":
case "spam_sum":
return Field.DatItem_SpamSum;
Finish string -> Field
2020-08-25 12:15:28 -07:00
case "merge":
case "mergetag":
case "merge_tag":
return Field.DatItem_Merge;
case "region":
return Field.DatItem_Region;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "offset":
return Field.DatItem_Offset;
Finish string -> Field
2020-08-25 12:15:28 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "date":
return Field.DatItem_Date;
Finish string -> Field
2020-08-25 12:15:28 -07:00
case "status":
return Field.DatItem_Status;
case "optional":
return Field.DatItem_Optional;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "inverted":
return Field.DatItem_Inverted;
Finish string -> Field
2020-08-25 12:15:28 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
// Rom (AttractMode)
case "altname":
case "alt name":
case "alt-name":
case "altromname":
case "alt romname":
case "alt-romname":
return Field.DatItem_AltName;
case "alttitle":
case "alt title":
case "alt-title":
case "altromtitle":
case "alt romtitle":
case "alt-romtitle":
return Field.DatItem_AltTitle;
// Rom (OpenMSX)
case "original":
return Field.DatItem_Original;
case "subtype":
case "sub_type":
case "openmsxsubtype":
case "openmsx_subtype":
return Field.DatItem_OpenMSXSubType;
case "openmsxtype":
case "openmsx_type":
return Field.DatItem_OpenMSXType;
case "remark":
return Field.DatItem_Remark;
case "boot":
return Field.DatItem_Boot;
Value is only part of certain items This is yet another boilerplate reduction AS WELL AS a reduction for unnecessary field names (mostly due to my misunderstanding of my own implementation)
2020-09-03 11:48:30 -07:00
// Rom (SoftwareList)
case "areaname":
case "area_name":
return Field.DatItem_AreaName;
case "areasize":
case "area_size":
return Field.DatItem_AreaSize;
case "areawidth":
case "area_width":
return Field.DatItem_AreaWidth;
case "areaendinanness":
case "area_endianness":
return Field.DatItem_AreaEndianness;
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "loadflag":
case "load_flag":
return Field.DatItem_LoadFlag;
case "partname":
case "part_name":
return Field.DatItem_Part_Name;
case "partinterface":
case "part_interface":
return Field.DatItem_Part_Interface;
case "part_feature_name":
return Field.DatItem_Part_Feature_Name;
case "part_feature_value":
return Field.DatItem_Part_Feature_Value;
Value is only part of certain items This is yet another boilerplate reduction AS WELL AS a reduction for unnecessary field names (mostly due to my misunderstanding of my own implementation)
2020-09-03 11:48:30 -07:00
case "value":
return Field.DatItem_Value;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
// Disk
case "index":
return Field.DatItem_Index;
Finish string -> Field
2020-08-25 12:15:28 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "writable":
return Field.DatItem_Writable;
Finish string -> Field
2020-08-25 12:15:28 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
#endregion
Finish string -> Field
2020-08-25 12:15:28 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
#region Auxiliary
Finish string -> Field
2020-08-25 12:15:28 -07:00
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
// Adjuster
case "default":
return Field.DatItem_Default;
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
// Analog
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "analog_mask":
return Field.DatItem_Analog_Mask;
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
// BiosSet
case "description":
case "biosdescription":
case "bios_description":
return Field.DatItem_Description;
Finish string -> Field
2020-08-25 12:15:28 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
// Chip
case "tag":
return Field.DatItem_Tag;
case "chiptype":
case "chip_type":
return Field.DatItem_ChipType;
case "clock":
return Field.DatItem_Clock;
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
// Condition
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "mask":
return Field.DatItem_Mask;
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
case "relation":
return Field.DatItem_Relation;
Promote Configuration
2020-09-01 11:55:11 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "condition_tag":
return Field.DatItem_Condition_Tag;
Promote Configuration
2020-09-01 11:55:11 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "condition_mask":
return Field.DatItem_Condition_Mask;
Promote Configuration
2020-09-01 11:55:11 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "condition_relation":
return Field.DatItem_Condition_Relation;
Promote Configuration
2020-09-01 11:55:11 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "condition_value":
return Field.DatItem_Condition_Value;
Promote Configuration
2020-09-01 11:55:11 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
// Control
case "control_type":
return Field.DatItem_Control_Type;
Promote Configuration
2020-09-01 11:55:11 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "control_player":
return Field.DatItem_Control_Player;
Promote Configuration
2020-09-01 11:55:11 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "control_buttons":
return Field.DatItem_Control_Buttons;
Promote Configuration
2020-09-01 11:55:11 -07:00
Add ControlType, fix a bunch of numerics
2020-09-06 23:00:13 -07:00
case "control_reqbuttons":
return Field.DatItem_Control_RequiredButtons;
Promote Configuration
2020-09-01 11:55:11 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "control_minimum":
return Field.DatItem_Control_Minimum;
Promote DipSwitch
2020-09-01 13:36:32 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "control_maximum":
return Field.DatItem_Control_Maximum;
Promote DipSwitch
2020-09-01 13:36:32 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "control_sensitivity":
return Field.DatItem_Control_Sensitivity;
Promote DipSwitch
2020-09-01 13:36:32 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "control_keydelta":
return Field.DatItem_Control_KeyDelta;
case "control_reverse":
return Field.DatItem_Control_Reverse;
case "control_ways":
return Field.DatItem_Control_Ways;
case "control_ways2":
return Field.DatItem_Control_Ways2;
case "control_ways3":
return Field.DatItem_Control_Ways3;
Promote DipSwitch
2020-09-01 13:36:32 -07:00
Promote Device
2020-09-02 17:09:19 -07:00
// Device
case "devicetype":
return Field.DatItem_DeviceType;
case "fixedimage":
return Field.DatItem_FixedImage;
case "mandatory":
return Field.DatItem_Mandatory;
case "interface":
return Field.DatItem_Interface;
Promote Display
2020-09-02 21:36:14 -07:00
// Display
case "displaytype":
return Field.DatItem_DisplayType;
case "rotate":
return Field.DatItem_Rotate;
case "flipx":
return Field.DatItem_FlipX;
case "width":
return Field.DatItem_Width;
case "height":
return Field.DatItem_Height;
case "refresh":
return Field.DatItem_Refresh;
case "pixclock":
return Field.DatItem_PixClock;
case "htotal":
return Field.DatItem_HTotal;
case "hbend":
return Field.DatItem_HBEnd;
case "hbstart":
return Field.DatItem_HBStart;
case "vtotal":
return Field.DatItem_VTotal;
case "vbend":
return Field.DatItem_VBEnd;
case "vbstart":
return Field.DatItem_VBStart;
Promote Driver
2020-09-02 15:38:10 -07:00
// Driver
case "supportstatus":
return Field.DatItem_SupportStatus;
case "emulationstatus":
return Field.DatItem_EmulationStatus;
case "cocktailstatus":
return Field.DatItem_CocktailStatus;
case "savestatestatus":
return Field.DatItem_SaveStateStatus;
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
// Extension
case "extension_name":
return Field.DatItem_Extension_Name;
Promote Feature
2020-09-02 13:31:50 -07:00
// Feature
case "featuretype":
return Field.DatItem_FeatureType;
case "featurestatus":
return Field.DatItem_FeatureStatus;
case "featureoverall":
return Field.DatItem_FeatureOverall;
Promote Input
2020-09-02 21:59:26 -07:00
// Input
case "service":
return Field.DatItem_Service;
case "tilt":
return Field.DatItem_Tilt;
case "players":
return Field.DatItem_Players;
case "coins":
return Field.DatItem_Coins;
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
// Instance
case "instance_name":
return Field.DatItem_Instance_Name;
Promote Input
2020-09-02 21:59:26 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "instance_briefname":
return Field.DatItem_Instance_BriefName;
Promote Input
2020-09-02 21:59:26 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
// Location
case "location_name":
return Field.DatItem_Location_Name;
Promote Input
2020-09-02 21:59:26 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "location_number":
return Field.DatItem_Location_Number;
Promote Port
2020-09-02 17:22:31 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
case "location_inverted":
return Field.DatItem_Location_Inverted;
Promote Port
2020-09-02 17:22:31 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
// RamOption
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
case "content":
return Field.DatItem_Content;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
// Release
case "language":
return Field.DatItem_Language;
Finish string -> Field
2020-08-25 12:15:28 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
// Setting
case "setting_name":
case "value_name":
return Field.DatItem_Setting_Name;
case "setting_value":
case "value_value":
return Field.DatItem_Setting_Value;
case "setting_default":
case "value_default":
return Field.DatItem_Setting_Default;
Promote Slot to DatItem
2020-09-01 16:21:55 -07:00
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
// SlotOption
Promote Slot to DatItem
2020-09-01 16:21:55 -07:00
case "slotoption_name":
return Field.DatItem_SlotOption_Name;
case "slotoption_devicename":
return Field.DatItem_SlotOption_DeviceName;
case "slotoption_default":
return Field.DatItem_SlotOption_Default;
Field enum cleanup, part 1
2020-09-03 14:22:15 -07:00
// SoftwareList
Promote SoftwareList
2020-08-31 23:26:07 -07:00
case "softwareliststatus":
case "softwarelist_status":
return Field.DatItem_SoftwareListStatus;
case "filter":
return Field.DatItem_Filter;
Promote Sound
2020-09-02 12:51:21 -07:00
// Sound
case "channels":
return Field.DatItem_Channels;
Promote Info
2020-09-02 23:31:35 -07:00
#endregion
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
Promote Info
2020-09-02 23:31:35 -07:00
#endregion // Item-Specific
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
}
}
// Else, we fall back on the old matching
Finish string -> Field
2020-08-25 12:15:28 -07:00
// TODO: Remove this entirely
Perf improvements, fix regex
2020-09-02 00:24:46 -07:00
// TODO: Normalize space replacement
switch (input)
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
{
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
#region Machine
#region Common
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
case "game":
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "gamename":
case "game-name":
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
case "machine":
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "machinename":
case "machine-name":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Name;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "comment":
case "extra":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Comment;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "desc":
case "description":
case "gamedesc":
case "gamedescription":
case "game-description":
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
case "game description":
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "machinedesc":
case "machinedescription":
case "machine-description":
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
case "machine description":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Description;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "year":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Year;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "manufacturer":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Manufacturer;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "publisher":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Publisher;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "category":
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
case "gamecategory":
case "game-category":
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "machinecategory":
case "machine-category":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Category;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "romof":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_RomOf;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "cloneof":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_CloneOf;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "sampleof":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_SampleOf;
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
MachineType is common, add Logiqx header values
2020-08-20 15:39:32 -07:00
case "gametype":
case "game type":
case "game-type":
case "machinetype":
case "machine type":
case "machine-type":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Type;
MachineType is common, add Logiqx header values
2020-08-20 15:39:32 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
#endregion
#region AttractMode
case "players":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Players;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "rotation":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Rotation;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "control":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Control;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "amstatus":
case "am-status":
case "gamestatus":
case "game-status":
case "machinestatus":
case "machine-status":
case "supportstatus":
case "support-status":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.Machine_Status;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "displaycount":
case "display-count":
case "displays":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_DisplayCount;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "displaytype":
case "display-type":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_DisplayType;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "buttons":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Buttons;
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
#endregion
#region ListXML
case "sourcefile":
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
case "source file":
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "source-file":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_SourceFile;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "runnable":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Runnable;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
#endregion
#region Logiqx
case "board":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Board;
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "rebuildto":
Normalize with SeparatedValue
2020-08-20 14:48:49 -07:00
case "rebuild to":
case "rebuild-to":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_RebuildTo;
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
#endregion
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#region Logiqx EmuArc
case "titleid":
case "title id":
case "title-id":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_TitleID;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
case "developer":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Developer;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
case "genre":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Genre;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
case "subgenre":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Subgenre;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
case "ratings":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Ratings;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
case "score":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Score;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
case "enabled":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Enabled;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
case "hascrc":
case "has crc":
case "has-crc":
Finish string -> Field
2020-08-25 12:15:28 -07:00
return Field.Machine_CRC;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
case "relatedto":
case "related to":
case "related-to":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_RelatedTo;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
Wire up remaining OpenMSX machine fields
2020-08-21 17:27:11 -07:00
#region OpenMSX
case "genmsxid":
case "genmsx id":
case "genmsx-id":
case "gen msx id":
case "gen-msx-id":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_GenMSXID;
Wire up remaining OpenMSX machine fields
2020-08-21 17:27:11 -07:00
case "system":
case "msxsystem":
case "msx system":
case "msx-system":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_System;
Wire up remaining OpenMSX machine fields
2020-08-21 17:27:11 -07:00
case "country":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Country;
Wire up remaining OpenMSX machine fields
2020-08-21 17:27:11 -07:00
#endregion
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
#region SoftwareList
case "supported":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.Machine_Supported;
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
#endregion
#endregion // Machine
#region DatItem
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
#region Common
case "itemname":
case "item-name":
case "name":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.DatItem_Name;
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
case "itemtype":
case "item-type":
case "type":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.DatItem_Type;
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
#endregion
#region AttractMode
case "altname":
case "alt name":
case "alt-name":
case "altromname":
case "alt romname":
case "alt-romname":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.DatItem_AltName;
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
case "alttitle":
case "alt title":
case "alt-title":
case "altromtitle":
case "alt romtitle":
case "alt-romtitle":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.DatItem_AltTitle;
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
#endregion
Wire up remaining OpenMSX DatItem fields
2020-08-21 23:48:35 -07:00
#region OpenMSX
case "original":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.DatItem_Original;
Wire up remaining OpenMSX DatItem fields
2020-08-21 23:48:35 -07:00
case "subtype":
case "sub type":
case "sub-type":
case "openmsx_subtype":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.DatItem_OpenMSXSubType;
Wire up remaining OpenMSX DatItem fields
2020-08-21 23:48:35 -07:00
case "openmsx_type":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.DatItem_OpenMSXType;
Wire up remaining OpenMSX DatItem fields
2020-08-21 23:48:35 -07:00
case "remark":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.DatItem_Remark;
Wire up remaining OpenMSX DatItem fields
2020-08-21 23:48:35 -07:00
case "boot":
So many fields and TODOs...
2020-08-24 22:25:47 -07:00
return Field.DatItem_Boot;
Wire up remaining OpenMSX DatItem fields
2020-08-21 23:48:35 -07:00
#endregion
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
#region SoftwareList
case "partname":
case "part name":
case "part-name":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_Part_Name;
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
case "partinterface":
case "part interface":
case "part-interface":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_Part_Interface;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "areaname":
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
case "area name":
Filter Abstraction (#25) * Add category, back filters by dictionary * Complete internal filter set * Fix AreaSize filter * Populate filter object the hard way * Manipulation flags should not be filters * None of them need to be public * Convert to partial helper method * Better method use * Field, not string; no dictionary * Add FilterTo method for later * More naming options (easier conversion) * Update README
2020-07-18 21:35:17 -07:00
case "area-name":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_AreaName;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "areasize":
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
case "area size":
Filter Abstraction (#25) * Add category, back filters by dictionary * Complete internal filter set * Fix AreaSize filter * Populate filter object the hard way * Manipulation flags should not be filters * None of them need to be public * Convert to partial helper method * Better method use * Field, not string; no dictionary * Add FilterTo method for later * More naming options (easier conversion) * Update README
2020-07-18 21:35:17 -07:00
case "area-size":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_AreaSize;
Wire up area width, endianness for SL
2020-08-21 13:31:22 -07:00
case "areawidth":
case "area width":
case "area-width":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_AreaWidth;
Wire up area width, endianness for SL
2020-08-21 13:31:22 -07:00
case "areaendinanness":
case "area endianness":
case "area-endianness":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_AreaEndianness;
Wire up value and loadflag for SL
2020-08-21 14:20:17 -07:00
case "value":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_Value;
Wire up value and loadflag for SL
2020-08-21 14:20:17 -07:00
case "loadflag":
case "load flag":
case "load-flag":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_LoadFlag;
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
#endregion
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
#region Item-Specific
Chip gets a promotion
2020-08-25 22:48:46 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
#region Actionable
Chip gets a promotion
2020-08-25 22:48:46 -07:00
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
// Rom
case "bios":
return Field.DatItem_Bios;
Chip gets a promotion
2020-08-25 22:48:46 -07:00
Filter Abstraction (#25) * Add category, back filters by dictionary * Complete internal filter set * Fix AreaSize filter * Populate filter object the hard way * Manipulation flags should not be filters * None of them need to be public * Convert to partial helper method * Better method use * Field, not string; no dictionary * Add FilterTo method for later * More naming options (easier conversion) * Update README
2020-07-18 21:35:17 -07:00
case "equal":
case "greater":
case "less":
case "size":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_Size;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "crc":
case "crc32":
return Field.DatItem_CRC;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "md5":
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "md5_hash":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_MD5;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#if NET_FRAMEWORK
case "ripemd160":
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "ripemd160_hash":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_RIPEMD160;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#endif
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "sha1":
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "sha_1":
case "sha1hash":
case "sha1_hash":
case "sha_1hash":
case "sha_1_hash":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_SHA1;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "sha256":
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "sha_256":
case "sha256hash":
case "sha256_hash":
case "sha_256hash":
case "sha_256_hash":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_SHA256;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "sha384":
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "sha_384":
case "sha384hash":
case "sha384_hash":
case "sha_384hash":
case "sha_384_hash":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_SHA384;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "sha512":
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "sha_512":
case "sha512hash":
case "sha512_hash":
case "sha_512hash":
case "sha_512_hash":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_SHA512;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
Add and use SpamSum for Media and Rom types SpamSum implementation courtesy of https://github.com/aaru-dps/Aaru
2020-09-04 15:02:15 -07:00
case "spamsum":
case "spam_sum":
return Field.DatItem_SpamSum;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "merge":
case "mergetag":
case "merge_tag":
return Field.DatItem_Merge;
case "region":
return Field.DatItem_Region;
case "offset":
return Field.DatItem_Offset;
case "date":
return Field.DatItem_Date;
case "itemtatus":
case "item-status":
case "status":
return Field.DatItem_Status;
case "optional":
return Field.DatItem_Optional;
case "inverted":
return Field.DatItem_Inverted;
// Disk
case "index":
return Field.DatItem_Index;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "writable":
Checkpoint (nw)
2020-08-25 11:20:50 -07:00
return Field.DatItem_Writable;
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
#endregion
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
#region Auxiliary
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
// Adjuster
case "default":
return Field.DatItem_Default;
case "condition_tag":
return Field.DatItem_Condition_Tag;
case "condition_mask":
return Field.DatItem_Condition_Mask;
case "condition_relation":
return Field.DatItem_Condition_Relation;
case "condition_value":
return Field.DatItem_Condition_Value;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
// BiosSet
case "biosdescription":
case "bios-description":
case "biossetdescription":
case "biosset-description":
case "bios-set-description":
return Field.DatItem_Description;
// Chip
case "tag":
return Field.DatItem_Tag;
case "chiptype":
case "chip_type":
return Field.DatItem_ChipType;
case "clock":
return Field.DatItem_Clock;
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
// Ram Option
case "content":
return Field.DatItem_Content;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
// Release
case "language":
return Field.DatItem_Language;
#endregion
#endregion // Item-Specific
#endregion
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
default:
return Field.NULL;
}
}
/// <summary>
/// Get ItemStatus value from input string
/// </summary>
/// <param name="status">String to get value from</param>
/// <returns>ItemStatus value corresponding to the string</returns>
public static ItemStatus AsItemStatus(this string status)
{
#if NET_FRAMEWORK
switch (status?.ToLowerInvariant())
{
case "good":
return ItemStatus.Good;
case "baddump":
return ItemStatus.BadDump;
case "nodump":
case "yes":
return ItemStatus.Nodump;
case "verified":
return ItemStatus.Verified;
case "none":
case "no":
default:
return ItemStatus.None;
}
#else
return status?.ToLowerInvariant() switch
{
"good" => ItemStatus.Good,
"baddump" => ItemStatus.BadDump,
"nodump" => ItemStatus.Nodump,
"yes" => ItemStatus.Nodump,
"verified" => ItemStatus.Verified,
"none" => ItemStatus.None,
"no" => ItemStatus.None,
_ => ItemStatus.None,
};
#endif
}
/// <summary>
/// Get ItemType? value from input string
/// </summary>
/// <param name="itemType">String to get value from</param>
/// <returns>ItemType? value corresponding to the string</returns>
public static ItemType? AsItemType(this string itemType)
{
#if NET_FRAMEWORK
switch (itemType?.ToLowerInvariant())
{
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
case "adjuster":
return ItemType.Adjuster;
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
case "analog":
return ItemType.Analog;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "archive":
return ItemType.Archive;
case "biosset":
return ItemType.BiosSet;
case "blank":
return ItemType.Blank;
Chip gets a promotion
2020-08-25 22:48:46 -07:00
case "chip":
return ItemType.Chip;
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
case "condition":
return ItemType.Condition;
Fix stats/creation for Configuration
2020-09-01 12:04:35 -07:00
case "configuration":
return ItemType.Configuration;
Promote Control
2020-09-02 23:02:06 -07:00
case "control":
return ItemType.Control;
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
case "dataarea":
return ItemType.DataArea;
Promote Device
2020-09-02 17:09:19 -07:00
case "device":
return ItemType.Device;
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case "device_ref":
return ItemType.DeviceReference;
Promote DipSwitch
2020-09-01 13:36:32 -07:00
case "dipswitch":
return ItemType.DipSwitch;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "disk":
return ItemType.Disk;
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
case "diskarea":
return ItemType.DiskArea;
Promote Display
2020-09-02 21:36:14 -07:00
case "display":
return ItemType.Display;
Promote Driver
2020-09-02 15:38:10 -07:00
case "driver":
return ItemType.Driver;
Promote Extension early
2020-09-02 16:37:01 -07:00
case "extension":
return ItemType.Extension;
Promote Feature
2020-09-02 13:31:50 -07:00
case "feature":
return ItemType.Feature;
Promote Info
2020-09-02 23:31:35 -07:00
case "info":
return ItemType.Info;
Promote Input
2020-09-02 21:59:26 -07:00
case "input":
return ItemType.Input;
Promote Instance early
2020-09-02 16:46:17 -07:00
case "instance":
return ItemType.Instance;
Handle Configuration; promote Location, Setting
2020-09-02 22:38:00 -07:00
case "location":
return ItemType.Location;
Add Aaruformat validation and `media` item type (#29) * Initial `media` and AaruFormat code * But... why? * Fix AIF reading * Fix D2D, Logiqx cleanup * Minor cleanup * Final cleanup round
2020-08-27 16:57:22 -07:00
case "media":
return ItemType.Media;
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
case "part":
return ItemType.Part;
Cleanup usings, promote PartFeature
2020-09-03 13:20:56 -07:00
case "partfeature":
case "part_feature":
return ItemType.PartFeature;
Promote Port
2020-09-02 17:22:31 -07:00
case "port":
return ItemType.Port;
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
case "ramoption":
return ItemType.RamOption;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
case "release":
return ItemType.Release;
case "rom":
return ItemType.Rom;
case "sample":
return ItemType.Sample;
Handle Configuration; promote Location, Setting
2020-09-02 22:38:00 -07:00
case "setting":
return ItemType.Setting;
Promote SharedFeature
2020-09-03 00:48:07 -07:00
case "sharedfeat":
return ItemType.SharedFeature;
Promote Slot to DatItem
2020-09-01 16:21:55 -07:00
case "slot":
return ItemType.Slot;
Promote SlotOption
2020-09-02 22:44:54 -07:00
case "slotoption":
return ItemType.SlotOption;
Promote SoftwareList
2020-08-31 23:26:07 -07:00
case "softwarelist":
return ItemType.SoftwareList;
Promote Sound
2020-09-02 12:51:21 -07:00
case "sound":
return ItemType.Sound;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
default:
return null;
}
#else
return itemType?.ToLowerInvariant() switch
{
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
"adjuster" => ItemType.Adjuster,
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
"analog" => ItemType.Analog,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
"archive" => ItemType.Archive,
"biosset" => ItemType.BiosSet,
"blank" => ItemType.Blank,
Chip gets a promotion
2020-08-25 22:48:46 -07:00
"chip" => ItemType.Chip,
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
"condition" => ItemType.Condition,
Fix stats/creation for Configuration
2020-09-01 12:04:35 -07:00
"configuration" => ItemType.Configuration,
Promote Control
2020-09-02 23:02:06 -07:00
"control" => ItemType.Control,
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
"dataarea" => ItemType.DataArea,
Promote Device
2020-09-02 17:09:19 -07:00
"device" => ItemType.Device,
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
"device_ref" => ItemType.DeviceReference,
Promote DipSwitch
2020-09-01 13:36:32 -07:00
"dipswitch" => ItemType.DipSwitch,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
"disk" => ItemType.Disk,
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
"diskarea" => ItemType.DiskArea,
Promote Display
2020-09-02 21:36:14 -07:00
"display" => ItemType.Display,
Promote Driver
2020-09-02 15:38:10 -07:00
"driver" => ItemType.Driver,
Promote Extension early
2020-09-02 16:37:01 -07:00
"extension" => ItemType.Extension,
Promote Feature
2020-09-02 13:31:50 -07:00
"feature" => ItemType.Feature,
Promote Info
2020-09-02 23:31:35 -07:00
"info" => ItemType.Info,
Promote Input
2020-09-02 21:59:26 -07:00
"input" => ItemType.Input,
Promote Instance early
2020-09-02 16:46:17 -07:00
"instance" => ItemType.Instance,
Handle Configuration; promote Location, Setting
2020-09-02 22:38:00 -07:00
"location" => ItemType.Location,
Add Aaruformat validation and `media` item type (#29) * Initial `media` and AaruFormat code * But... why? * Fix AIF reading * Fix D2D, Logiqx cleanup * Minor cleanup * Final cleanup round
2020-08-27 16:57:22 -07:00
"media" => ItemType.Media,
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
"part" => ItemType.Part,
Cleanup usings, promote PartFeature
2020-09-03 13:20:56 -07:00
"partfeature" => ItemType.PartFeature,
"part_feature" => ItemType.PartFeature,
Promote Port
2020-09-02 17:22:31 -07:00
"port" => ItemType.Port,
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
"ramoption" => ItemType.RamOption,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
"release" => ItemType.Release,
"rom" => ItemType.Rom,
"sample" => ItemType.Sample,
Handle Configuration; promote Location, Setting
2020-09-02 22:38:00 -07:00
"setting" => ItemType.Setting,
Promote SharedFeature
2020-09-03 00:48:07 -07:00
"sharedfeat" => ItemType.SharedFeature,
Promote Slot to DatItem
2020-09-01 16:21:55 -07:00
"slot" => ItemType.Slot,
Promote SlotOption
2020-09-02 22:44:54 -07:00
"slotoption" => ItemType.SlotOption,
Promote SoftwareList
2020-08-31 23:26:07 -07:00
"softwarelist" => ItemType.SoftwareList,
Promote Sound
2020-09-02 12:51:21 -07:00
"sound" => ItemType.Sound,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
_ => null,
};
#endif
}
Create and use DisplayType, LoadFlag enums
2020-09-03 21:32:00 -07:00
/// <summary>
/// Get LoadFlag value from input string
/// </summary>
/// <param name="loadFlag">String to get value from</param>
/// <returns>LoadFlag value corresponding to the string</returns>
public static LoadFlag AsLoadFlag(this string loadFlag)
{
#if NET_FRAMEWORK
switch (loadFlag?.ToLowerInvariant())
{
case "load16_byte":
return LoadFlag.Load16Byte;
case "load16_word":
return LoadFlag.Load16Word;
case "load16_word_swap":
return LoadFlag.Load16WordSwap;
case "load32_byte":
return LoadFlag.Load32Byte;
case "load32_word":
return LoadFlag.Load32Word;
case "load32_word_swap":
return LoadFlag.Load32WordSwap;
case "load32_dword":
return LoadFlag.Load32DWord;
case "load64_word":
return LoadFlag.Load64Word;
case "load64_word_swap":
return LoadFlag.Load64WordSwap;
case "reload":
return LoadFlag.Reload;
case "fill":
return LoadFlag.Fill;
case "continue":
return LoadFlag.Continue;
case "reload_plain":
return LoadFlag.ReloadPlain;
Typos and such
2020-09-05 23:15:48 -07:00
case "ignore":
Create and use DisplayType, LoadFlag enums
2020-09-03 21:32:00 -07:00
return LoadFlag.Ignore;
default:
return LoadFlag.NULL;
}
#else
return loadFlag?.ToLowerInvariant() switch
{
"load16_byte" => LoadFlag.Load16Byte,
"load16_word" => LoadFlag.Load16Word,
"load16_word_swap" => LoadFlag.Load16WordSwap,
"load32_byte" => LoadFlag.Load32Byte,
"load32_word" => LoadFlag.Load32Word,
"load32_word_swap" => LoadFlag.Load32WordSwap,
"load32_dword" => LoadFlag.Load32DWord,
"load64_word" => LoadFlag.Load64Word,
"load64_word_swap" => LoadFlag.Load64WordSwap,
"reload" => LoadFlag.Reload,
"fill" => LoadFlag.Fill,
"continue" => LoadFlag.Continue,
"reload_plain" => LoadFlag.ReloadPlain,
"ignore" => LoadFlag.Ignore,
_ => LoadFlag.NULL,
};
#endif
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
/// <summary>
/// Get MachineType value from input string
/// </summary>
/// <param name="gametype">String to get value from</param>
/// <returns>MachineType value corresponding to the string</returns>
public static MachineType AsMachineType(this string gametype)
{
#if NET_FRAMEWORK
switch (gametype?.ToLowerInvariant())
{
case "bios":
return MachineType.Bios;
case "dev":
case "device":
return MachineType.Device;
case "mech":
case "mechanical":
return MachineType.Mechanical;
case "none":
default:
Remove MachineType.None (dupe of NULL)
2020-08-24 13:53:53 -07:00
return MachineType.NULL;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
}
#else
return gametype?.ToLowerInvariant() switch
{
"bios" => MachineType.Bios,
"dev" => MachineType.Device,
"device" => MachineType.Device,
"mech" => MachineType.Mechanical,
"mechanical" => MachineType.Mechanical,
Remove MachineType.None (dupe of NULL)
2020-08-24 13:53:53 -07:00
"none" => MachineType.NULL,
_ => MachineType.NULL,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
};
#endif
}
Move to MergingFlag
2020-08-20 20:38:29 -07:00
/// <summary>
/// Get MergingFlag value from input string
/// </summary>
/// <param name="merging">String to get value from</param>
/// <returns>MergingFlag value corresponding to the string</returns>
public static MergingFlag AsMergingFlag(this string merging)
{
#if NET_FRAMEWORK
switch (merging?.ToLowerInvariant())
{
case "split":
return MergingFlag.Split;
case "merged":
return MergingFlag.Merged;
case "nonmerged":
case "unmerged":
return MergingFlag.NonMerged;
case "full":
return MergingFlag.Full;
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
case "device":
return MergingFlag.Device;
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case "none":
default:
return MergingFlag.None;
}
#else
return merging?.ToLowerInvariant() switch
{
"split" => MergingFlag.Split,
"merged" => MergingFlag.Merged,
"nonmerged" => MergingFlag.NonMerged,
"unmerged" => MergingFlag.NonMerged,
"full" => MergingFlag.Full,
"none" => MergingFlag.None,
_ => MergingFlag.None,
};
#endif
}
/// <summary>
/// Get NodumpFlag value from input string
/// </summary>
/// <param name="nodump">String to get value from</param>
/// <returns>NodumpFlag value corresponding to the string</returns>
public static NodumpFlag AsNodumpFlag(this string nodump)
{
#if NET_FRAMEWORK
switch (nodump?.ToLowerInvariant())
{
case "obsolete":
return NodumpFlag.Obsolete;
case "required":
return NodumpFlag.Required;
case "ignore":
return NodumpFlag.Ignore;
case "none":
default:
return NodumpFlag.None;
}
#else
return nodump?.ToLowerInvariant() switch
{
"obsolete" => NodumpFlag.Obsolete,
"required" => NodumpFlag.Required,
"ignore" => NodumpFlag.Ignore,
"none" => NodumpFlag.None,
_ => NodumpFlag.None,
};
#endif
}
Wire up remaining OpenMSX DatItem fields
2020-08-21 23:48:35 -07:00
/// <summary>
/// Get OpenMSXSubType value from input string
/// </summary>
/// <param name="itemType">String to get value from</param>
/// <returns>OpenMSXSubType value corresponding to the string</returns>
public static OpenMSXSubType AsOpenMSXSubType(this string itemType)
{
#if NET_FRAMEWORK
switch (itemType?.ToLowerInvariant())
{
case "rom":
return OpenMSXSubType.Rom;
case "megarom":
return OpenMSXSubType.MegaRom;
case "sccpluscart":
return OpenMSXSubType.SCCPlusCart;
default:
return OpenMSXSubType.NULL;
}
#else
return itemType?.ToLowerInvariant() switch
{
"rom" => OpenMSXSubType.Rom,
"megarom" => OpenMSXSubType.MegaRom,
"sccpluscart" => OpenMSXSubType.SCCPlusCart,
_ => OpenMSXSubType.NULL,
};
#endif
}
Move to MergingFlag
2020-08-20 20:38:29 -07:00
/// <summary>
/// Get PackingFlag value from input string
/// </summary>
/// <param name="packing">String to get value from</param>
/// <returns>PackingFlag value corresponding to the string</returns>
public static PackingFlag AsPackingFlag(this string packing)
{
#if NET_FRAMEWORK
switch (packing?.ToLowerInvariant())
{
case "yes":
case "zip":
return PackingFlag.Zip;
case "no":
case "unzip":
return PackingFlag.Unzip;
Add new packing flags
2020-08-28 19:15:23 -07:00
case "partial":
return PackingFlag.Partial;
case "flat":
return PackingFlag.Flat;
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case "none":
default:
return PackingFlag.None;
}
#else
return packing?.ToLowerInvariant() switch
{
"yes" => PackingFlag.Zip,
"zip" => PackingFlag.Zip,
"no" => PackingFlag.Unzip,
"unzip" => PackingFlag.Unzip,
Add new packing flags
2020-08-28 19:15:23 -07:00
"partial" => PackingFlag.Partial,
"flat" => PackingFlag.Flat,
Move to MergingFlag
2020-08-20 20:38:29 -07:00
"none" => PackingFlag.None,
_ => PackingFlag.None,
};
#endif
}
Add and use Relation enum
2020-09-03 21:59:53 -07:00
/// <summary>
/// Get Relation value from input string
/// </summary>
/// <param name="relation">String to get value from</param>
/// <returns>Relation value corresponding to the string</returns>
public static Relation AsRelation(this string relation)
{
#if NET_FRAMEWORK
switch (relation?.ToLowerInvariant())
{
case "eq":
return Relation.Equal;
case "ne":
return Relation.NotEqual;
case "gt":
return Relation.GreaterThan;
case "le":
return Relation.LessThanOrEqual;
case "lt":
return Relation.LessThan;
case "ge":
return Relation.GreaterThanOrEqual;
default:
return Relation.NULL;
}
#else
return relation?.ToLowerInvariant() switch
{
"eq" => Relation.Equal,
"ne" => Relation.NotEqual,
"gt" => Relation.GreaterThan,
"le" => Relation.LessThanOrEqual,
"lt" => Relation.LessThan,
"ge" => Relation.GreaterThanOrEqual,
_ => Relation.NULL,
};
#endif
}
Add a remaining ListXML-specific objects Also fixes the usage of some other objects, adds proper objects for certain cases, and adds a bunch of TODOs around the new objects. There will be a lot of overhauls needed to properly support things like Devices and Slots
2020-08-23 15:34:42 -07:00
/// <summary>
/// Get Runnable value from input string
/// </summary>
/// <param name="runnable">String to get value from</param>
/// <returns>Runnable value corresponding to the string</returns>
public static Runnable AsRunnable(this string runnable)
{
#if NET_FRAMEWORK
switch (runnable?.ToLowerInvariant())
{
case "no":
return Runnable.No;
case "partial":
return Runnable.Partial;
case "yes":
return Runnable.Yes;
default:
return Runnable.NULL;
}
#else
return runnable?.ToLowerInvariant() switch
{
"no" => Runnable.No,
"partial" => Runnable.Partial,
"yes" => Runnable.Yes,
_ => Runnable.NULL,
};
#endif
}
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
/// <summary>
/// Get SoftwareListStatus value from input string
/// </summary>
/// <param name="status">String to get value from</param>
/// <returns>SoftwareListStatus value corresponding to the string</returns>
public static SoftwareListStatus AsSoftwareListStatus(this string status)
{
#if NET_FRAMEWORK
switch (status?.ToLowerInvariant())
{
case "original":
return SoftwareListStatus.Original;
case "compatible":
return SoftwareListStatus.Compatible;
case "none":
default:
return SoftwareListStatus.NULL;
}
#else
return status?.ToLowerInvariant() switch
{
"original" => SoftwareListStatus.Original,
"compatible" => SoftwareListStatus.Compatible,
"none" => SoftwareListStatus.NULL,
_ => SoftwareListStatus.NULL,
};
#endif
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
/// <summary>
/// Get StatReportFormat value from input string
/// </summary>
/// <param name="input">String to get value from</param>
/// <returns>StatReportFormat value corresponding to the string</returns>
public static StatReportFormat AsStatReportFormat(this string input)
{
#if NET_FRAMEWORK
switch (input?.Trim().ToLowerInvariant())
{
case "all":
return StatReportFormat.All;
case "csv":
return StatReportFormat.CSV;
case "html":
return StatReportFormat.HTML;
case "ssv":
return StatReportFormat.SSV;
case "text":
return StatReportFormat.Textfile;
case "tsv":
return StatReportFormat.TSV;
default:
return 0x0;
}
#else
return input?.Trim().ToLowerInvariant() switch
{
"all" => StatReportFormat.All,
"csv" => StatReportFormat.CSV,
"html" => StatReportFormat.HTML,
"ssv" => StatReportFormat.SSV,
"text" => StatReportFormat.Textfile,
"tsv" => StatReportFormat.TSV,
_ => 0x0,
};
#endif
}
Change Supported to Enum
2020-08-22 13:31:13 -07:00
/// <summary>
/// Get Supported value from input string
/// </summary>
/// <param name="supported">String to get value from</param>
/// <returns>Supported value corresponding to the string</returns>
public static Supported AsSupported(this string supported)
{
#if NET_FRAMEWORK
switch (supported?.ToLowerInvariant())
{
case "no":
Promote Driver
2020-09-02 15:38:10 -07:00
case "unsupported":
Change Supported to Enum
2020-08-22 13:31:13 -07:00
return Supported.No;
case "partial":
return Supported.Partial;
case "yes":
Promote Driver
2020-09-02 15:38:10 -07:00
case "supported":
Change Supported to Enum
2020-08-22 13:31:13 -07:00
return Supported.Yes;
default:
return Supported.NULL;
}
#else
return supported?.ToLowerInvariant() switch
{
"no" => Supported.No,
Promote Driver
2020-09-02 15:38:10 -07:00
"unsupported" => Supported.No,
Change Supported to Enum
2020-08-22 13:31:13 -07:00
"partial" => Supported.Partial,
"yes" => Supported.Yes,
Promote Driver
2020-09-02 15:38:10 -07:00
"supported" => Supported.Yes,
Change Supported to Enum
2020-08-22 13:31:13 -07:00
_ => Supported.NULL,
};
#endif
}
Promote Driver
2020-09-02 15:38:10 -07:00
/// <summary>
/// Get SupportStatus value from input string
/// </summary>
/// <param name="supported">String to get value from</param>
/// <returns>SupportStatus value corresponding to the string</returns>
public static SupportStatus AsSupportStatus(this string supportStatus)
{
#if NET_FRAMEWORK
switch (supportStatus?.ToLowerInvariant())
{
case "good":
return SupportStatus.Good;
case "imperfect":
return SupportStatus.Imperfect;
case "preliminary":
return SupportStatus.Preliminary;
default:
return SupportStatus.NULL;
}
#else
return supportStatus?.ToLowerInvariant() switch
{
"good" => SupportStatus.Good,
"imperfect" => SupportStatus.Imperfect,
"preliminary" => SupportStatus.Preliminary,
_ => SupportStatus.NULL,
};
#endif
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
/// <summary>
/// Get bool? value from input string
/// </summary>
/// <param name="yesno">String to get value from</param>
/// <returns>bool? corresponding to the string</returns>
public static bool? AsYesNo(this string yesno)
{
#if NET_FRAMEWORK
switch (yesno?.ToLowerInvariant())
{
case "yes":
Add support for inverted CRC flag
2020-07-28 17:00:19 -07:00
case "true":
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
return true;
case "no":
Add support for inverted CRC flag
2020-07-28 17:00:19 -07:00
case "false":
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
return false;
default:
return null;
}
#else
return yesno?.ToLowerInvariant() switch
{
"yes" => true,
Add support for inverted CRC flag
2020-07-28 17:00:19 -07:00
"true" => true,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
"no" => false,
Add support for inverted CRC flag
2020-07-28 17:00:19 -07:00
"false" => false,
Better optional attributes
2020-08-23 22:54:09 -07:00
_ => null,
};
#endif
}
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
#endregion
#region Enum to String
// TODO: DatFormat -> string
// TODO: Field -> string
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
/// <summary>
/// Get string value from input ChipType
/// </summary>
/// <param name="chipType">ChipType to get value from</param>
/// <returns>String value corresponding to the ChipType</returns>
public static string FromChipType(this ChipType chipType)
{
#if NET_FRAMEWORK
switch (chipType)
{
case ChipType.CPU:
return "cpu";
case ChipType.Audio:
return "audio";
default:
return null;
}
#else
return chipType switch
{
ChipType.CPU => "cpu",
ChipType.Audio => "audio",
_ => null,
};
#endif
}
Add ControlType, fix a bunch of numerics
2020-09-06 23:00:13 -07:00
/// <summary>
/// Get string value from input ControlType
/// </summary>
/// <param name="controlType">ControlType to get value from</param>
/// <returns>String value corresponding to the ControlType</returns>
public static string FromControlType(this ControlType controlType)
{
#if NET_FRAMEWORK
switch (controlType)
{
case ControlType.Joy:
return "joy";
case ControlType.Stick:
return "stick";
case ControlType.Paddle:
return "paddle";
case ControlType.Pedal:
return "pedal";
case ControlType.Lightgun:
return "lightgun";
case ControlType.Positional:
return "positional";
case ControlType.Dial:
return "dial";
case ControlType.Trackball:
return "trackball";
case ControlType.Mouse:
return "mouse";
case ControlType.OnlyButtons:
return "only_buttons";
case ControlType.Keypad:
return "keypad";
case ControlType.Keyboard:
return "keyboard";
case ControlType.Mahjong:
return "mahjong";
case ControlType.Hanafuda:
return "hanafuda";
case ControlType.Gambling:
return "gambling";
default:
return null;
}
#else
return controlType switch
{
ControlType.Joy => "joy",
ControlType.Stick => "stick",
ControlType.Paddle => "paddle",
ControlType.Pedal => "pedal",
ControlType.Lightgun => "lightgun",
ControlType.Positional => "positional",
ControlType.Dial => "dial",
ControlType.Trackball => "trackball",
ControlType.Mouse => "mouse",
ControlType.OnlyButtons => "only_buttons",
ControlType.Keypad => "keypad",
ControlType.Keyboard => "keyboard",
ControlType.Mahjong => "mahjong",
ControlType.Hanafuda => "hanafuda",
ControlType.Gambling => "gambling",
_ => null,
};
#endif
}
Add and use DeviceType
2020-09-07 00:39:59 -07:00
/// <summary>
/// Get string value from input DeviceType
/// </summary>
/// <param name="deviceType">vDeviceType to get value from</param>
/// <returns>String value corresponding to the DeviceType</returns>
public static string FromDeviceType(this DeviceType deviceType)
{
#if NET_FRAMEWORK
switch (deviceType)
{
case DeviceType.Unknown:
return "unknown";
case DeviceType.Cartridge:
return "cartridge";
case DeviceType.FloppyDisk:
return "floppydisk";
case DeviceType.HardDisk:
return "harddisk";
case DeviceType.Cylinder:
return "cylinder";
case DeviceType.Cassette:
return "cassette";
case DeviceType.PunchCard:
return "punchcard";
case DeviceType.PunchTape:
return "punchtape";
case DeviceType.Printout:
return "printout";
case DeviceType.Serial:
return "serial";
case DeviceType.Parallel:
return "parallel";
case DeviceType.Snapshot:
return "snapshot";
case DeviceType.QuickLoad:
return "quickload";
case DeviceType.MemCard:
return "memcard";
case DeviceType.CDROM:
return "cdrom";
case DeviceType.MagTape:
return "magtape";
case DeviceType.ROMImage:
return "romimage";
case DeviceType.MIDIIn:
return "midiin";
case DeviceType.MIDIOut:
return "midiout";
case DeviceType.Picture:
return "picture";
case DeviceType.VidFile:
return "vidfile";
default:
return null;
}
#else
return deviceType switch
{
DeviceType.Unknown => "unknown",
DeviceType.Cartridge => "cartridge",
DeviceType.FloppyDisk => "floppydisk",
DeviceType.HardDisk => "harddisk",
DeviceType.Cylinder => "cylinder",
DeviceType.Cassette => "cassette",
DeviceType.PunchCard => "punchcard",
DeviceType.PunchTape => "punchtape",
DeviceType.Printout => "printout",
DeviceType.Serial => "serial",
DeviceType.Parallel => "parallel",
DeviceType.Snapshot => "snapshot",
DeviceType.QuickLoad => "quickload",
DeviceType.MemCard => "memcard",
DeviceType.CDROM => "cdrom",
DeviceType.MagTape => "magtape",
DeviceType.ROMImage => "romimage",
DeviceType.MIDIIn => "midiin",
DeviceType.MIDIOut => "midiout",
DeviceType.Picture => "picture",
DeviceType.VidFile => "vidfile",
_ => null,
};
#endif
}
Create and use DisplayType, LoadFlag enums
2020-09-03 21:32:00 -07:00
/// <summary>
/// Get string value from input DisplayType
/// </summary>
/// <param name="displayType">DisplayType to get value from</param>
/// <returns>String value corresponding to the DisplayType</returns>
public static string FromDisplayType(this DisplayType displayType)
{
#if NET_FRAMEWORK
switch (displayType)
{
case DisplayType.Raster:
return "raster";
case DisplayType.Vector:
return "vector";
case DisplayType.LCD:
return "lcd";
case DisplayType.SVG:
return "svg";
case DisplayType.Unknown:
return "unknown";
default:
return null;
}
#else
return displayType switch
{
DisplayType.Raster => "raster",
DisplayType.Vector => "vector",
DisplayType.LCD => "lcd",
DisplayType.SVG => "svg",
DisplayType.Unknown => "unknown",
_ => null,
};
#endif
}
Add and use Endianness enum
2020-09-03 21:39:16 -07:00
/// <summary>
/// Get string value from input Endianness
/// </summary>
/// <param name="endianness">Endianness to get value from</param>
/// <returns>String value corresponding to the Endianness</returns>
public static string FromEndianness(this Endianness endianness)
{
#if NET_FRAMEWORK
switch (endianness)
{
case Endianness.Big:
return "big";
case Endianness.Little:
return "little";
default:
return null;
}
#else
return endianness switch
{
Endianness.Big => "big",
Endianness.Little => "little",
_ => null,
};
#endif
}
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
/// <summary>
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
/// Get string value from input FeatureStatus
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
/// </summary>
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
/// <param name="featureStatus">FeatureStatus to get value from</param>
/// <returns>String value corresponding to the FeatureStatus</returns>
public static string FromFeatureStatus(this FeatureStatus featureStatus)
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
{
#if NET_FRAMEWORK
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
switch (featureStatus)
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
{
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
case FeatureStatus.Unemulated:
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
return "unemulated";
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
case FeatureStatus.Imperfect:
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
return "imperfect";
default:
return null;
}
#else
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
return featureStatus switch
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
{
EmulationStatus -> FeatureStatus
2020-09-02 14:34:41 -07:00
FeatureStatus.Unemulated => "unemulated",
FeatureStatus.Imperfect => "imperfect",
Add ChipType and EmulationStatus, fix serialization
2020-09-02 14:32:16 -07:00
_ => null,
};
#endif
}
Create and use DatItems.FeatureType
2020-09-02 14:04:02 -07:00
/// <summary>
/// Get string value from input FeatureType
/// </summary>
/// <param name="featureType">FeatureType to get value from</param>
/// <returns>String value corresponding to the FeatureType</returns>
public static string FromFeatureType(this FeatureType featureType)
{
#if NET_FRAMEWORK
switch (featureType)
{
case FeatureType.Protection:
return "protection";
case FeatureType.Palette:
return "palette";
case FeatureType.Graphics:
return "graphics";
case FeatureType.Sound:
return "sound";
case FeatureType.Controls:
return "controls";
case FeatureType.Keyboard:
return "keyboard";
case FeatureType.Mouse:
return "mouse";
case FeatureType.Microphone:
return "microphone";
case FeatureType.Camera:
return "camera";
case FeatureType.Disk:
return "disk";
case FeatureType.Printer:
return "printer";
case FeatureType.Lan:
return "lan";
case FeatureType.Wan:
return "wan";
case FeatureType.Timing:
return "timing";
default:
return null;
}
#else
return featureType switch
{
FeatureType.Protection => "protection",
FeatureType.Palette => "palette",
FeatureType.Graphics => "graphics",
FeatureType.Sound => "sound",
FeatureType.Controls => "controls",
FeatureType.Keyboard => "keyboard",
FeatureType.Mouse => "mouse",
FeatureType.Microphone => "microphone",
FeatureType.Camera => "camera",
FeatureType.Disk => "disk",
FeatureType.Printer => "printer",
FeatureType.Lan => "lan",
FeatureType.Wan => "wan",
FeatureType.Timing => "timing",
_ => null,
};
#endif
}
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
/// <summary>
/// Get string value from input ItemStatus
/// </summary>
/// <param name="status">ItemStatus to get value from</param>
/// <param name="yesno">True to use Yes/No format instead</param>
/// <returns>String value corresponding to the ItemStatus</returns>
public static string FromItemStatus(this ItemStatus status, bool yesno)
{
#if NET_FRAMEWORK
switch (status)
{
case ItemStatus.Good:
return "good";
case ItemStatus.BadDump:
return "baddump";
case ItemStatus.Nodump:
return yesno ? "yes" : "nodump";
case ItemStatus.Verified:
return "verified";
default:
return null;
}
#else
return status switch
{
ItemStatus.Good => "good",
ItemStatus.BadDump => "baddump",
ItemStatus.Nodump => yesno ? "yes" : "nodump",
ItemStatus.Verified => "verified",
_ => null,
};
#endif
}
Create and use DisplayType, LoadFlag enums
2020-09-03 21:32:00 -07:00
/// <summary>
/// Get string value from input LoadFlag
/// </summary>
/// <param name="loadFlag">LoadFlag to get value from</param>
/// <returns>String value corresponding to the LoadFlag</returns>
public static string FromLoadFlag(this LoadFlag loadFlag)
{
#if NET_FRAMEWORK
switch (loadFlag)
{
case LoadFlag.Load16Byte:
return "load16_byte";
case LoadFlag.Load16Word:
return "load16_word";
case LoadFlag.Load16WordSwap:
return "load16_word_swap";
case LoadFlag.Load32Byte:
return "load32_byte";
case LoadFlag.Load32Word:
return "load32_word";
case LoadFlag.Load32WordSwap:
return "load32_word_swap";
case LoadFlag.Load32DWord:
return "load32_dword";
case LoadFlag.Load64Word:
return "load64_word";
case LoadFlag.Load64WordSwap:
return "load64_word_swap";
case LoadFlag.Reload:
return "reload";
case LoadFlag.Fill:
return "fill";
case LoadFlag.Continue:
return "continue";
case LoadFlag.ReloadPlain:
return "reload_plain";
case LoadFlag.Ignore:
return "sccpluscart";
default:
return null;
}
#else
return loadFlag switch
{
LoadFlag.Load16Byte => "load16_byte",
LoadFlag.Load16Word => "load16_word",
LoadFlag.Load16WordSwap => "load16_word_swap",
LoadFlag.Load32Byte => "load32_byte",
LoadFlag.Load32Word => "load32_word",
LoadFlag.Load32WordSwap => "load32_word_swap",
LoadFlag.Load32DWord => "load32_dword",
LoadFlag.Load64Word => "load64_word",
LoadFlag.Load64WordSwap => "load64_word_swap",
LoadFlag.Reload => "reload",
LoadFlag.Fill => "fill",
LoadFlag.Continue => "continue",
LoadFlag.ReloadPlain => "reload_plain",
LoadFlag.Ignore => "ignore",
_ => null,
};
#endif
}
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
/// <summary>
/// Get string value from input ItemType?
/// </summary>
/// <param name="itemType">ItemType? to get value from</param>
/// <returns>String value corresponding to the ItemType?</returns>
public static string FromItemType(this ItemType? itemType)
{
#if NET_FRAMEWORK
switch (itemType)
{
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
case ItemType.Adjuster:
return "adjuster";
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
case ItemType.Analog:
return "analog";
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
case ItemType.Archive:
return "archive";
case ItemType.BiosSet:
return "biosset";
case ItemType.Blank:
return "blank";
Chip gets a promotion
2020-08-25 22:48:46 -07:00
case ItemType.Chip:
return "chip";
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
case ItemType.Condition:
return "condition";
Fix stats/creation for Configuration
2020-09-01 12:04:35 -07:00
case ItemType.Configuration:
return "configuration";
Promote Control
2020-09-02 23:02:06 -07:00
case ItemType.Control:
return "control";
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
case ItemType.DataArea:
return "dataarea";
Promote Device
2020-09-02 17:09:19 -07:00
case ItemType.Device:
return "device";
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
case ItemType.DeviceReference:
return "device_ref";
Promote DipSwitch
2020-09-01 13:36:32 -07:00
case ItemType.DipSwitch:
return "dipswitch";
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
case ItemType.Disk:
return "disk";
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
case ItemType.DiskArea:
return "diskarea";
Promote Display
2020-09-02 21:36:14 -07:00
case ItemType.Display:
return "display";
Promote Driver
2020-09-02 15:38:10 -07:00
case ItemType.Driver:
return "driver";
Promote Extension early
2020-09-02 16:37:01 -07:00
case ItemType.Extension:
return "extension";
Promote Feature
2020-09-02 13:31:50 -07:00
case ItemType.Feature:
return "feature";
Promote Info
2020-09-02 23:31:35 -07:00
case ItemType.Info:
return "info";
Promote Input
2020-09-02 21:59:26 -07:00
case ItemType.Input:
return "input";
Promote Instance early
2020-09-02 16:46:17 -07:00
case ItemType.Instance:
return "instance";
Handle Configuration; promote Location, Setting
2020-09-02 22:38:00 -07:00
case ItemType.Location:
return "location";
Add Aaruformat validation and `media` item type (#29) * Initial `media` and AaruFormat code * But... why? * Fix AIF reading * Fix D2D, Logiqx cleanup * Minor cleanup * Final cleanup round
2020-08-27 16:57:22 -07:00
case ItemType.Media:
return "media";
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
case ItemType.Part:
return "part";
Cleanup usings, promote PartFeature
2020-09-03 13:20:56 -07:00
case ItemType.PartFeature:
return "part_feature";
Promote Port
2020-09-02 17:22:31 -07:00
case ItemType.Port:
return "port";
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
case ItemType.RamOption:
return "ramoption";
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
case ItemType.Release:
return "release";
case ItemType.Rom:
return "rom";
case ItemType.Sample:
return "sample";
Handle Configuration; promote Location, Setting
2020-09-02 22:38:00 -07:00
case ItemType.Setting:
return "setting";
Promote SharedFeature
2020-09-03 00:48:07 -07:00
case ItemType.SharedFeature:
return "sharedfeat";
Promote Slot to DatItem
2020-09-01 16:21:55 -07:00
case ItemType.Slot:
return "slot";
Promote SlotOption
2020-09-02 22:44:54 -07:00
case ItemType.SlotOption:
return "slotoption";
Promote SoftwareList
2020-08-31 23:26:07 -07:00
case ItemType.SoftwareList:
return "softwarelist";
Promote Sound
2020-09-02 12:51:21 -07:00
case ItemType.Sound:
return "sound";
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
default:
return null;
}
#else
return itemType switch
{
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
ItemType.Adjuster => "adjuster",
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
ItemType.Analog => "analog",
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
ItemType.Archive => "archive",
ItemType.BiosSet => "biosset",
ItemType.Blank => "blank",
Chip gets a promotion
2020-08-25 22:48:46 -07:00
ItemType.Chip => "chip",
Promote Analog early, promot Configuration
2020-09-02 16:31:23 -07:00
ItemType.Condition => "condition",
Fix stats/creation for Configuration
2020-09-01 12:04:35 -07:00
ItemType.Configuration => "configuration",
Promote Control
2020-09-02 23:02:06 -07:00
ItemType.Control => "control",
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
ItemType.DataArea => "dataarea",
Promote Device
2020-09-02 17:09:19 -07:00
ItemType.Device => "device",
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
ItemType.DeviceReference => "device_ref",
Promote DipSwitch
2020-09-01 13:36:32 -07:00
ItemType.DipSwitch => "dipswitch",
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
ItemType.Disk => "disk",
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
ItemType.DiskArea => "diskarea",
Promote Display
2020-09-02 21:36:14 -07:00
ItemType.Display => "display",
Promote Driver
2020-09-02 15:38:10 -07:00
ItemType.Driver => "driver",
Promote Extension early
2020-09-02 16:37:01 -07:00
ItemType.Extension => "extension",
Promote Feature
2020-09-02 13:31:50 -07:00
ItemType.Feature => "feature",
Promote Info
2020-09-02 23:31:35 -07:00
ItemType.Info => "info",
Promote Input
2020-09-02 21:59:26 -07:00
ItemType.Input => "input",
Promote Instance early
2020-09-02 16:46:17 -07:00
ItemType.Instance => "instance",
Handle Configuration; promote Location, Setting
2020-09-02 22:38:00 -07:00
ItemType.Location => "location",
Add Aaruformat validation and `media` item type (#29) * Initial `media` and AaruFormat code * But... why? * Fix AIF reading * Fix D2D, Logiqx cleanup * Minor cleanup * Final cleanup round
2020-08-27 16:57:22 -07:00
ItemType.Media => "media",
Promote DataArea, DiskArea, and Part
2020-09-04 14:10:35 -07:00
ItemType.Part => "part",
Cleanup usings, promote PartFeature
2020-09-03 13:20:56 -07:00
ItemType.PartFeature => "part_feature",
Promote Port
2020-09-02 17:22:31 -07:00
ItemType.Port => "port",
Promote Adjuster, RamOption
2020-09-01 11:34:52 -07:00
ItemType.RamOption => "ramoption",
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
ItemType.Release => "release",
ItemType.Rom => "rom",
ItemType.Sample => "sample",
Handle Configuration; promote Location, Setting
2020-09-02 22:38:00 -07:00
ItemType.Setting => "setting",
Promote SharedFeature
2020-09-03 00:48:07 -07:00
ItemType.SharedFeature => "sharedfeat",
Promote Slot to DatItem
2020-09-01 16:21:55 -07:00
ItemType.Slot => "slot",
Promote SlotOption
2020-09-02 22:44:54 -07:00
ItemType.SlotOption => "slotoption",
Promote SoftwareList
2020-08-31 23:26:07 -07:00
ItemType.SoftwareList => "softwarelist",
Promote Sound
2020-09-02 12:51:21 -07:00
ItemType.Sound => "sound",
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
_ => null,
};
#endif
}
/// <summary>
/// Get string value from input MachineType
/// </summary>
/// <param name="gametype">MachineType to get value from</param>
/// <param name="romCenter">True to use old naming instead</param>
/// <returns>String value corresponding to the MachineType</returns>
public static string FromMachineType(this MachineType gametype, bool old)
{
#if NET_FRAMEWORK
switch (gametype)
{
case MachineType.Bios:
return "bios";
case MachineType.Device:
return old ? "dev" : "device";
case MachineType.Mechanical:
return old ? "mech" : "mechanical";
default:
return null;
}
#else
return gametype switch
{
MachineType.Bios => "bios",
MachineType.Device => old ? "dev" : "device",
MachineType.Mechanical => old ? "mech" : "mechanical",
_ => null,
};
#endif
}
/// <summary>
/// Get string value from input MergingFlag
/// </summary>
/// <param name="merging">MergingFlag to get value from</param>
/// <param name="romCenter">True to use RomCenter naming instead</param>
/// <returns>String value corresponding to the MergingFlag</returns>
public static string FromMergingFlag(this MergingFlag merging, bool romCenter)
{
#if NET_FRAMEWORK
switch (merging)
{
case MergingFlag.Split:
return "split";
case MergingFlag.Merged:
return "merged";
case MergingFlag.NonMerged:
return romCenter ? "unmerged" : "nonmerged";
case MergingFlag.Full:
return "full";
case MergingFlag.Device:
return "device";
default:
return null;
}
#else
return merging switch
{
MergingFlag.Split => "split",
MergingFlag.Merged => "merged",
MergingFlag.NonMerged => romCenter ? "unmerged" : "nonmerged",
MergingFlag.Full => "full",
MergingFlag.Device => "device",
_ => null,
};
#endif
}
/// <summary>
/// Get string value from input NodumpFlag
/// </summary>
/// <param name="nodump">NodumpFlag to get value from</param>
/// <returns>String value corresponding to the NodumpFlag</returns>
public static string FromNodumpFlag(this NodumpFlag nodump)
{
#if NET_FRAMEWORK
switch (nodump)
{
case NodumpFlag.Obsolete:
return "obsolete";
case NodumpFlag.Required:
return "required";
case NodumpFlag.Ignore:
return "ignore";
default:
return null;
}
#else
return nodump switch
{
NodumpFlag.Obsolete => "obsolete",
NodumpFlag.Required => "required",
NodumpFlag.Ignore => "ignore",
_ => null,
};
#endif
}
/// <summary>
/// Get string value from input OpenMSXSubType
/// </summary>
/// <param name="itemType">OpenMSXSubType to get value from</param>
/// <returns>String value corresponding to the OpenMSXSubType</returns>
public static string FromOpenMSXSubType(this OpenMSXSubType itemType)
{
#if NET_FRAMEWORK
switch (itemType)
{
case OpenMSXSubType.Rom:
return "rom";
case OpenMSXSubType.MegaRom:
return "megarom";
case OpenMSXSubType.SCCPlusCart:
return "sccpluscart";
default:
return null;
}
#else
return itemType switch
{
OpenMSXSubType.Rom => "rom",
OpenMSXSubType.MegaRom => "megarom",
OpenMSXSubType.SCCPlusCart => "sccpluscart",
_ => null,
};
#endif
}
Reduce redundant code
2020-08-28 22:21:35 -07:00
/// <summary>
/// Get string value from input OutputFormat
/// </summary>
/// <param name="itemType">OutputFormat to get value from</param>
/// <returns>String value corresponding to the OutputFormat</returns>
public static string FromOutputFormat(this OutputFormat itemType)
{
#if NET_FRAMEWORK
switch (itemType)
{
case OutputFormat.Folder:
case OutputFormat.ParentFolder:
return "directory";
case OutputFormat.TapeArchive:
return "TAR";
case OutputFormat.Torrent7Zip:
return "Torrent7Z";
case OutputFormat.TorrentGzip:
case OutputFormat.TorrentGzipRomba:
return "TorrentGZ";
case OutputFormat.TorrentLRZip:
return "TorrentLRZ";
case OutputFormat.TorrentRar:
return "TorrentRAR";
case OutputFormat.TorrentXZ:
case OutputFormat.TorrentXZRomba:
return "TorrentXZ";
case OutputFormat.TorrentZip:
return "TorrentZip";
default:
return null;
}
#else
return itemType switch
{
OutputFormat.Folder => "directory",
OutputFormat.ParentFolder => "directory",
OutputFormat.TapeArchive => "TAR",
OutputFormat.Torrent7Zip => "Torrent7Z",
OutputFormat.TorrentGzip => "TorrentGZ",
OutputFormat.TorrentGzipRomba => "TorrentGZ",
OutputFormat.TorrentLRZip => "TorrentLRZ",
OutputFormat.TorrentRar => "TorrentRAR",
OutputFormat.TorrentXZ => "TorrentXZ",
OutputFormat.TorrentXZRomba => "TorrentXZ",
OutputFormat.TorrentZip => "TorrentZip",
_ => null,
};
#endif
}
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
/// <summary>
/// Get string value from input PackingFlag
/// </summary>
/// <param name="packing">PackingFlag to get value from</param>
/// <param name="yesno">True to use Yes/No format instead</param>
/// <returns>String value corresponding to the PackingFlag</returns>
public static string FromPackingFlag(this PackingFlag packing, bool yesno)
{
#if NET_FRAMEWORK
switch (packing)
{
case PackingFlag.Zip:
return yesno ? "yes" : "zip";
case PackingFlag.Unzip:
return yesno ? "no" : "unzip";
Add new packing flags
2020-08-28 19:15:23 -07:00
case PackingFlag.Partial:
return "partial";
case PackingFlag.Flat:
return "flat";
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
default:
return null;
}
#else
return packing switch
{
PackingFlag.Zip => yesno ? "yes" : "zip",
PackingFlag.Unzip => yesno ? "yes" : "zip",
Add new packing flags
2020-08-28 19:15:23 -07:00
PackingFlag.Partial => "partial",
PackingFlag.Flat => "flat",
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
_ => null,
};
#endif
}
Add and use Relation enum
2020-09-03 21:59:53 -07:00
/// <summary>
/// Get string value from input Relation
/// </summary>
/// <param name="relation">Relation to get value from</param>
/// <returns>String value corresponding to the Relation</returns>
public static string FromRelation(this Relation relation)
{
#if NET_FRAMEWORK
switch (relation)
{
case Relation.Equal:
return "eq";
case Relation.NotEqual:
return "ne";
case Relation.GreaterThan:
return "gt";
case Relation.LessThanOrEqual:
return "le";
case Relation.LessThan:
return "lt";
case Relation.GreaterThanOrEqual:
return "ge";
default:
return null;
}
#else
return relation switch
{
Relation.Equal => "eq",
Relation.NotEqual => "ne",
Relation.GreaterThan => "gt",
Relation.LessThanOrEqual => "le",
Relation.LessThan => "lt",
Relation.GreaterThanOrEqual => "ge",
_ => null,
};
#endif
}
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
/// <summary>
/// Get string value from input Runnable
/// </summary>
/// <param name="runnable">Runnable to get value from</param>
/// <returns>String value corresponding to the Runnable</returns>
public static string FromRunnable(this Runnable runnable)
{
#if NET_FRAMEWORK
switch (runnable)
{
case Runnable.No:
return "no";
case Runnable.Partial:
return "partial";
case Runnable.Yes:
return "yes";
default:
return null;
}
#else
return runnable switch
{
Runnable.No => "no",
Runnable.Partial => "partial",
Runnable.Yes => "yes",
_ => null,
};
#endif
}
Add DeviceReference type, cleanup TODOs
2020-08-31 23:01:51 -07:00
/// <summary>
/// Get string value from input SoftwareListStatus
/// </summary>
/// <param name="status">SoftwareListStatus to get value from</param>
/// <returns>String value corresponding to the SoftwareListStatus</returns>
public static string FromSoftwareListStatus(this SoftwareListStatus status)
{
#if NET_FRAMEWORK
switch (status)
{
case SoftwareListStatus.Original:
return "original";
case SoftwareListStatus.Compatible:
return "compatible";
default:
return null;
}
#else
return status switch
{
SoftwareListStatus.Original => "original",
SoftwareListStatus.Compatible => "compatible",
_ => null,
};
#endif
}
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
/// <summary>
/// Get string value from input StatReportFormat
/// </summary>
/// <param name="input">StatReportFormat to get value from</param>
/// <returns>String value corresponding to the StatReportFormat</returns>
public static string FromStatReportFormat(this StatReportFormat input)
{
#if NET_FRAMEWORK
switch (input)
{
case StatReportFormat.All:
return "all";
case StatReportFormat.CSV:
return "csv";
case StatReportFormat.HTML:
return "html";
case StatReportFormat.SSV:
return "ssv";
case StatReportFormat.Textfile:
return "text";
case StatReportFormat.TSV:
return "tsv";
default:
return null;
}
#else
return input switch
{
StatReportFormat.All => "all",
StatReportFormat.CSV => "csv",
StatReportFormat.HTML => "html",
StatReportFormat.SSV => "ssv",
StatReportFormat.Textfile => "text",
StatReportFormat.TSV => "tsv",
_ => null,
};
#endif
}
/// <summary>
/// Get string value from input Supported
/// </summary>
/// <param name="supported">Supported to get value from</param>
Promote Driver
2020-09-02 15:38:10 -07:00
/// <param name="verbose">True to use verbose output, false otherwise</param>
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
/// <returns>String value corresponding to the Supported</returns>
Promote Driver
2020-09-02 15:38:10 -07:00
public static string FromSupported(this Supported supported, bool verbose)
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
{
#if NET_FRAMEWORK
switch (supported)
{
case Supported.No:
Promote Driver
2020-09-02 15:38:10 -07:00
return verbose ? "unsupported" : "no";
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
case Supported.Partial:
return "partial";
case Supported.Yes:
Promote Driver
2020-09-02 15:38:10 -07:00
return verbose ? "supported" : "yes";
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
default:
return null;
}
#else
return supported switch
{
Supported.No => "no",
Supported.Partial => "partial",
Supported.Yes => "yes",
_ => null,
};
#endif
}
Use better XML methods
2020-08-24 00:25:23 -07:00
Promote Driver
2020-09-02 15:38:10 -07:00
/// <summary>
/// Get string value from input SupportStatus
/// </summary>
/// <param name="supportStatus">SupportStatus to get value from</param>
/// <returns>String value corresponding to the SupportStatus</returns>
public static string FromSupportStatus(this SupportStatus supportStatus)
{
#if NET_FRAMEWORK
switch (supportStatus)
{
case SupportStatus.Good:
return "good";
case SupportStatus.Imperfect:
return "imperfect";
case SupportStatus.Preliminary:
return "preliminary";
default:
return null;
}
#else
return supportStatus switch
{
SupportStatus.Good => "good",
SupportStatus.Imperfect => "imperfect",
SupportStatus.Preliminary => "preliminary",
_ => null,
};
#endif
}
Better optional attributes
2020-08-23 22:54:09 -07:00
/// <summary>
/// Get string value from input bool?
/// </summary>
/// <param name="yesno">bool? to get value from</param>
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
/// <returns>String corresponding to the bool?</returns>
Better optional attributes
2020-08-23 22:54:09 -07:00
public static string FromYesNo(this bool? yesno)
{
#if NET_FRAMEWORK
switch (yesno)
{
case true:
return "yes";
case false:
return "no";
default:
return null;
}
#else
return yesno switch
{
true => "yes",
false => "no",
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
_ => null,
};
#endif
}
Finish and use more enum conversions
2020-08-24 13:21:59 -07:00
#endregion
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
}
}
Reference in New Issue Copy Permalink