Parametrics (#276)

* Begin reducing complexity of parameters classes

* Make the method virtual, not the field

* Consolidate helper methods

* Fix "empty" commands; Fix DD generation

* Handle all sorts of numerical values

* Rip out remaining unneeded enum

MPF.Library/Aaru/Constants.cs

@@ -5,6 +5,8 @@ namespace MPF.Aaru
     /// </summary>
     public static class CommandStrings
     {
+        public const string NONE = "";
+
         // Database Family
         public const string DatabasePrefixShort = "db";
         public const string DatabasePrefixLong = "database";

MPF.Library/Aaru/Converters.cs

@@ -18,407 +18,5 @@ namespace MPF.Aaru
         }
 
         #endregion
-
-        #region Convert to Long Name
-
-        /// <summary>
-        /// Get the string representation of the Command enum values
-        /// </summary>
-        /// <param name="command">Command value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Command command)
-        {
-            switch (command)
-            {
-                // Database Family
-                case Command.DatabaseStats:
-                    return $"{CommandStrings.DatabasePrefixLong} {CommandStrings.DatabaseStats}";
-                case Command.DatabaseUpdate:
-                    return $"{CommandStrings.DatabasePrefixLong} {CommandStrings.DatabaseUpdate}";
-
-                // Device Family
-                case Command.DeviceInfo:
-                    return $"{CommandStrings.DevicePrefixLong} {CommandStrings.DeviceInfo}";
-                case Command.DeviceList:
-                    return $"{CommandStrings.DevicePrefixLong} {CommandStrings.DeviceList}";
-                case Command.DeviceReport:
-                    return $"{CommandStrings.DevicePrefixLong} {CommandStrings.DeviceReport}";
-
-                // Filesystem Family
-                case Command.FilesystemExtract:
-                    return $"{CommandStrings.FilesystemPrefixLong} {CommandStrings.FilesystemExtract}";
-                case Command.FilesystemList:
-                    return $"{CommandStrings.FilesystemPrefixLong} {CommandStrings.FilesystemListLong}";
-                case Command.FilesystemOptions:
-                    return $"{CommandStrings.FilesystemPrefixLong} {CommandStrings.FilesystemOptions}";
-
-                // Image Family
-                case Command.ImageAnalyze:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageAnalyze}";
-                case Command.ImageChecksum:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageChecksumLong}";
-                case Command.ImageCompare:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageCompareLong}";
-                case Command.ImageConvert:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageConvert}";
-                case Command.ImageCreateSidecar:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageCreateSidecar}";
-                case Command.ImageDecode:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageDecode}";
-                case Command.ImageEntropy:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageEntropy}";
-                case Command.ImageInfo:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageInfo}";
-                case Command.ImageOptions:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageOptions}";
-                case Command.ImagePrint:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImagePrint}";
-                case Command.ImageVerify:
-                    return $"{CommandStrings.ImagePrefixLong} {CommandStrings.ImageVerify}";
-
-                // Media Family
-                case Command.MediaDump:
-                    return $"{CommandStrings.MediaPrefixLong} {CommandStrings.MediaDump}";
-                case Command.MediaInfo:
-                    return $"{CommandStrings.MediaPrefixLong} {CommandStrings.MediaInfo}";
-                case Command.MediaScan:
-                    return $"{CommandStrings.MediaPrefixLong} {CommandStrings.MediaScan}";
-
-                // Standalone Commands
-                case Command.Configure:
-                    return CommandStrings.Configure;
-                case Command.Formats:
-                    return CommandStrings.Formats;
-                case Command.ListEncodings:
-                    return CommandStrings.ListEncodings;
-                case Command.ListNamespaces:
-                    return CommandStrings.ListNamespaces;
-                case Command.Remote:
-                    return CommandStrings.Remote;
-
-                case Command.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        /// <summary>
-        /// Get the string representation of the Flag enum values
-        /// </summary>
-        /// <param name="command">Flag value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Flag flag)
-        {
-            switch (flag)
-            {
-                // Boolean flags
-                case Flag.Adler32:
-                    return FlagStrings.Adler32Long;
-                case Flag.Clear:
-                    return FlagStrings.ClearLong;
-                case Flag.ClearAll:
-                    return FlagStrings.ClearAllLong;
-                case Flag.CRC16:
-                    return FlagStrings.CRC16Long;
-                case Flag.CRC32:
-                    return FlagStrings.CRC32Long;
-                case Flag.CRC64:
-                    return FlagStrings.CRC64Long;
-                case Flag.Debug:
-                    return FlagStrings.DebugLong;
-                case Flag.DiskTags:
-                    return FlagStrings.DiskTagsLong;
-                case Flag.DuplicatedSectors:
-                    return FlagStrings.DuplicatedSectorsLong;
-                case Flag.Eject:
-                    return FlagStrings.EjectLong;
-                case Flag.ExtendedAttributes:
-                    return FlagStrings.ExtendedAttributesLong;
-                case Flag.Filesystems:
-                    return FlagStrings.FilesystemsLong;
-                case Flag.FirstPregap:
-                    return FlagStrings.FirstPregapLong;
-                case Flag.FixOffset:
-                    return FlagStrings.FixOffsetLong;
-                case Flag.FixSubchannel:
-                    return FlagStrings.FixSubchannelLong;
-                case Flag.FixSubchannelCrc:
-                    return FlagStrings.FixSubchannelCrcLong;
-                case Flag.FixSubchannelPosition:
-                    return FlagStrings.FixSubchannelPositionLong;
-                case Flag.Fletcher16:
-                    return FlagStrings.Fletcher16Long;
-                case Flag.Fletcher32:
-                    return FlagStrings.Fletcher32Long;
-                case Flag.Force:
-                    return FlagStrings.ForceLong;
-                case Flag.GenerateSubchannels:
-                    return FlagStrings.GenerateSubchannelsLong;
-                case Flag.Help:
-                    return FlagStrings.HelpLong;
-                case Flag.LongFormat:
-                    return FlagStrings.LongFormatLong;
-                case Flag.LongSectors:
-                    return FlagStrings.LongSectorsLong;
-                case Flag.MD5:
-                    return FlagStrings.MD5Long;
-                case Flag.Metadata:
-                    return FlagStrings.MetadataLong;
-                case Flag.Partitions:
-                    return FlagStrings.PartitionsLong;
-                case Flag.Persistent:
-                    return FlagStrings.PersistentLong;
-                case Flag.Private:
-                    return FlagStrings.PrivateLong;
-                case Flag.Resume:
-                    return FlagStrings.ResumeLong;
-                case Flag.RetrySubchannel:
-                    return FlagStrings.RetrySubchannelLong;
-                case Flag.SectorTags:
-                    return FlagStrings.SectorTagsLong;
-                case Flag.SeparatedTracks:
-                    return FlagStrings.SeparatedTracksLong;
-                case Flag.SHA1:
-                    return FlagStrings.SHA1Long;
-                case Flag.SHA256:
-                    return FlagStrings.SHA256Long;
-                case Flag.SHA384:
-                    return FlagStrings.SHA384Long;
-                case Flag.SHA512:
-                    return FlagStrings.SHA512Long;
-                case Flag.SkipCdiReadyHole:
-                    return FlagStrings.SkipCdiReadyHoleLong;
-                case Flag.SpamSum:
-                    return FlagStrings.SpamSumLong;
-                case Flag.StopOnError:
-                    return FlagStrings.StopOnErrorLong;
-                case Flag.Tape:
-                    return FlagStrings.TapeLong;
-                case Flag.Trim:
-                    return FlagStrings.TrimLong;
-                case Flag.Verbose:
-                    return FlagStrings.VerboseLong;
-                case Flag.VerifyDisc:
-                    return FlagStrings.VerifyDiscLong;
-                case Flag.VerifySectors:
-                    return FlagStrings.VerifySectorsLong;
-                case Flag.Version:
-                    return FlagStrings.VersionLong;
-                case Flag.WholeDisc:
-                    return FlagStrings.WholeDiscLong;
-
-                // Int8 flags
-                case Flag.Speed:
-                    return FlagStrings.SpeedLong;
-
-                // Int16 flags
-                case Flag.RetryPasses:
-                    return FlagStrings.RetryPassesLong;
-                case Flag.Width:
-                    return FlagStrings.WidthLong;
-
-                // Int32 flags
-                case Flag.BlockSize:
-                    return FlagStrings.BlockSizeLong;
-                case Flag.Count:
-                    return FlagStrings.CountLong;
-                case Flag.MediaLastSequence:
-                    return FlagStrings.MediaLastSequenceLong;
-                case Flag.MediaSequence:
-                    return FlagStrings.MediaSequenceLong;
-                case Flag.Skip:
-                    return FlagStrings.SkipLong;
-
-                // Int64 flags
-                case Flag.Length:
-                    return FlagStrings.LengthLong;
-                case Flag.Start:
-                    return FlagStrings.StartLong;
-
-                // String flags
-                case Flag.Comments:
-                    return FlagStrings.CommentsLong;
-                case Flag.Creator:
-                    return FlagStrings.CreatorLong;
-                case Flag.DriveManufacturer:
-                    return FlagStrings.DriveManufacturerLong;
-                case Flag.DriveModel:
-                    return FlagStrings.DriveModelLong;
-                case Flag.DriveRevision:
-                    return FlagStrings.DriveRevisionLong;
-                case Flag.DriveSerial:
-                    return FlagStrings.DriveSerialLong;
-                case Flag.Encoding:
-                    return FlagStrings.EncodingLong;
-                case Flag.FormatConvert:
-                    return FlagStrings.FormatConvertLong;
-                case Flag.FormatDump:
-                    return FlagStrings.FormatDumpLong;
-                case Flag.ImgBurnLog:
-                    return FlagStrings.ImgBurnLogLong;
-                case Flag.MediaBarcode:
-                    return FlagStrings.MediaBarcodeLong;
-                case Flag.MediaManufacturer:
-                    return FlagStrings.MediaManufacturerLong;
-                case Flag.MediaModel:
-                    return FlagStrings.MediaModelLong;
-                case Flag.MediaPartNumber:
-                    return FlagStrings.MediaPartNumberLong;
-                case Flag.MediaSerial:
-                    return FlagStrings.MediaSerialLong;
-                case Flag.MediaTitle:
-                    return FlagStrings.MediaTitleLong;
-                case Flag.MHDDLog:
-                    return FlagStrings.MHDDLogLong;
-                case Flag.Namespace:
-                    return FlagStrings.NamespaceLong;
-                case Flag.Options:
-                    return FlagStrings.OptionsLong;
-                case Flag.OutputPrefix:
-                    return FlagStrings.OutputPrefixLong;
-                case Flag.ResumeFile:
-                    return FlagStrings.ResumeFileLong;
-                case Flag.Subchannel:
-                    return FlagStrings.SubchannelLong;
-                case Flag.XMLSidecar:
-                    return FlagStrings.XMLSidecarLong;
-
-                case Flag.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        #endregion
-
-        #region Convert From String
-
-        /// <summary>
-        /// Get the Command enum value for a given string
-        /// </summary>
-        /// <param name="commandOne">First part of String value to convert</param>
-        /// <param name="commandTwo">Second part of String value to convert</param>
-        /// <param name="useSecond">Output bool if the second command was used</param>
-        /// <returns>Command represented by the string(s), if possible</returns>
-        public static Command StringToCommand(string commandOne, string commandTwo, out bool useSecond)
-        {
-            useSecond = false;
-            switch (commandOne)
-            {
-                // Database Family
-                case CommandStrings.DatabasePrefixShort:
-                case CommandStrings.DatabasePrefixLong:
-                    useSecond = true;
-                    switch (commandTwo)
-                    {
-                        case CommandStrings.DatabaseStats:
-                            return Command.DatabaseStats;
-                        case CommandStrings.DatabaseUpdate:
-                            return Command.DatabaseUpdate;
-                    }
-
-                    break;
-
-                // Device Family
-                case CommandStrings.DevicePrefixShort:
-                case CommandStrings.DevicePrefixLong:
-                    useSecond = true;
-                    switch (commandTwo)
-                    {
-                        case CommandStrings.DeviceInfo:
-                            return Command.DeviceInfo;
-                        case CommandStrings.DeviceList:
-                            return Command.DeviceList;
-                        case CommandStrings.DeviceReport:
-                            return Command.DeviceReport;
-                    }
-
-                    break;
-
-                // Filesystem Family
-                case CommandStrings.FilesystemPrefixShort:
-                case CommandStrings.FilesystemPrefixShortAlt:
-                case CommandStrings.FilesystemPrefixLong:
-                    useSecond = true;
-                    switch (commandTwo)
-                    {
-                        case CommandStrings.FilesystemExtract:
-                            return Command.FilesystemExtract;
-                        case CommandStrings.FilesystemListShort:
-                        case CommandStrings.FilesystemListLong:
-                            return Command.FilesystemList;
-                        case CommandStrings.DatabaseStats:
-                            return Command.FilesystemOptions;
-                    }
-
-                    break;
-
-                // Image Family
-                case CommandStrings.ImagePrefixShort:
-                case CommandStrings.ImagePrefixLong:
-                    useSecond = true;
-                    switch (commandTwo)
-                    {
-                        case CommandStrings.ImageAnalyze:
-                            return Command.ImageAnalyze;
-                        case CommandStrings.ImageChecksumShort:
-                        case CommandStrings.ImageChecksumLong:
-                            return Command.ImageChecksum;
-                        case CommandStrings.ImageCompareShort:
-                        case CommandStrings.ImageCompareLong:
-                            return Command.ImageCompare;
-                        case CommandStrings.ImageConvert:
-                            return Command.ImageConvert;
-                        case CommandStrings.ImageCreateSidecar:
-                            return Command.ImageCreateSidecar;
-                        case CommandStrings.ImageDecode:
-                            return Command.ImageDecode;
-                        case CommandStrings.ImageEntropy:
-                            return Command.ImageEntropy;
-                        case CommandStrings.ImageInfo:
-                            return Command.ImageInfo;
-                        case CommandStrings.ImageOptions:
-                            return Command.ImageOptions;
-                        case CommandStrings.ImagePrint:
-                            return Command.ImagePrint;
-                        case CommandStrings.ImageVerify:
-                            return Command.ImageVerify;
-                    }
-
-                    break;
-
-                // Media Family
-                case CommandStrings.MediaPrefixShort:
-                case CommandStrings.MediaPrefixLong:
-                    useSecond = true;
-                    switch (commandTwo)
-                    {
-                        case CommandStrings.MediaDump:
-                            return Command.MediaDump;
-                        case CommandStrings.MediaInfo:
-                            return Command.MediaInfo;
-                        case CommandStrings.MediaScan:
-                            return Command.MediaScan;
-                    }
-
-                    break;
-
-                // Standalone Commands
-                case CommandStrings.Configure:
-                    return Command.Configure;
-                case CommandStrings.Formats:
-                    return Command.Formats;
-                case CommandStrings.ListEncodings:
-                    return Command.ListEncodings;
-                case CommandStrings.ListNamespaces:
-                    return Command.ListNamespaces;
-                case CommandStrings.Remote:
-                    return Command.Remote;
-            }
-
-            return Command.NONE;
-        }
-
-        #endregion
     }
 }

MPF.Library/Aaru/Enumerations.cs

@@ -1,149 +0,0 @@
-namespace MPF.Aaru
-{
-    /// <summary>
-    /// Supported Aaru commands
-    /// </summary>
-    public enum Command : int
-    {
-        NONE = 0,
-
-        // Database Family
-        DatabaseStats,
-        DatabaseUpdate,
-
-        // Device Family
-        DeviceInfo,
-        DeviceList,
-        DeviceReport,
-
-        // Filesystem Family
-        FilesystemExtract,
-        FilesystemList,
-        FilesystemOptions,
-
-        // Image Family
-        ImageAnalyze,
-        ImageChecksum,
-        ImageCompare,
-        ImageConvert,
-        ImageCreateSidecar,
-        ImageDecode,
-        ImageEntropy,
-        ImageInfo,
-        ImageOptions,
-        ImagePrint,
-        ImageVerify,
-
-        // Media Family
-        MediaDump,
-        MediaInfo,
-        MediaScan,
-
-        // Standalone Commands
-        Configure,
-        Formats,
-        ListEncodings,
-        ListNamespaces,
-        Remote,
-    }
-
-    /// <summary>
-    /// Supported Aaru flags
-    /// </summary>
-    public enum Flag : int
-    {
-        NONE = 0,
-
-        // Boolean flags
-        Adler32,
-        Clear,
-        ClearAll,
-        CRC16,
-        CRC32,
-        CRC64,
-        Debug,
-        DiskTags,
-        DuplicatedSectors,
-        Eject,
-        ExtendedAttributes,
-        Filesystems,
-        FirstPregap,
-        FixOffset,
-        FixSubchannel,
-        FixSubchannelCrc,
-        FixSubchannelPosition,
-        Fletcher16,
-        Fletcher32,
-        Force,
-        GenerateSubchannels,
-        Help,
-        LongFormat,
-        LongSectors,
-        MD5,
-        Metadata,
-        Partitions,
-        Persistent,
-        Private,
-        Resume,
-        RetrySubchannel,
-        SectorTags,
-        SeparatedTracks,
-        SHA1,
-        SHA256,
-        SHA384,
-        SHA512,
-        SkipCdiReadyHole,
-        SpamSum,
-        StopOnError,
-        Tape,
-        Trim,
-        Verbose,
-        VerifyDisc,
-        VerifySectors,
-        Version,
-        WholeDisc,
-
-        // Int8 flags
-        Speed,
-
-        // Int16 flags
-        RetryPasses,
-        Width,
-
-        // Int32 flags
-        BlockSize,
-        Count,
-        MediaLastSequence,
-        MediaSequence,
-        Skip,
-
-        // Int64 flags
-        Length,
-        Start,
-
-        // String flags
-        Comments,
-        Creator,
-        DriveManufacturer,
-        DriveModel,
-        DriveRevision,
-        DriveSerial,
-        Encoding,
-        FormatConvert,
-        FormatDump,
-        ImgBurnLog,
-        MediaBarcode,
-        MediaManufacturer,
-        MediaModel,
-        MediaPartNumber,
-        MediaSerial,
-        MediaTitle,
-        MHDDLog,
-        Namespace,
-        Options,
-        OutputPrefix,
-        ResumeFile,
-        Subchannel,
-        XMLSidecar,
-    }
-}

MPF.Library/CleanRIp/Parameters.cs

@@ -3,7 +3,6 @@ using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using MPF.Data;
-using MPF.Utilities;
 
 namespace MPF.CleanRip
 {

MPF.Library/DD/Constants.cs

@@ -5,6 +5,7 @@ namespace MPF.DD
     /// </summary>
     public static class CommandStrings
     {
+        public const string NONE = "";
         public const string List = "--list";
     }
 

MPF.Library/DD/Converters.cs

@@ -18,87 +18,5 @@ namespace MPF.DD
         }
 
         #endregion
-
-        #region Convert to Long Name
-
-        /// <summary>
-        /// Get the string representation of the Command enum values
-        /// </summary>
-        /// <param name="command">Command value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Command command)
-        {
-            switch (command)
-            {
-                case Command.List:
-                    return CommandStrings.List;
-
-                case Command.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        /// <summary>
-        /// Get the string representation of the Flag enum values
-        /// </summary>
-        /// <param name="command">Flag value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Flag flag)
-        {
-            switch (flag)
-            {
-                // Boolean flags
-                case Flag.Progress:
-                    return FlagStrings.Progress;
-                case Flag.Size:
-                    return FlagStrings.Size;
-
-                // Int64 flags
-                case Flag.BlockSize:
-                    return FlagStrings.BlockSize;
-                case Flag.Count:
-                    return FlagStrings.Count;
-                case Flag.Seek:
-                    return FlagStrings.Seek;
-                case Flag.Skip:
-                    return FlagStrings.Skip;
-
-                // String flags
-                case Flag.Filter:
-                    return FlagStrings.Filter;
-                case Flag.InputFile:
-                    return FlagStrings.InputFile;
-                case Flag.OutputFile:
-                    return FlagStrings.OutputFile;
-
-                case Flag.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        #endregion
-
-        #region Convert From String
-
-        /// <summary>
-        /// Get the Command enum value for a given string
-        /// </summary>
-        /// <param name="command">String value to convert</param>
-        /// <returns>Command represented by the string(s), if possible</returns>
-        public static Command StringToCommand(string command)
-        {
-            switch (command)
-            {
-                case CommandStrings.List:
-                    return Command.List;
-
-                default:
-                    return Command.NONE;
-            }
-        }
-
-        #endregion
     }
 }

MPF.Library/DD/Enumerations.cs

@@ -1,34 +0,0 @@
-namespace MPF.DD
-{
-    /// <summary>
-    /// Supported DD commands
-    /// </summary>
-    public enum Command: int
-    {
-        NONE = 0, // For DD, this represents a normal dump
-        List,
-    }
-
-    /// <summary>
-    /// Supported DD flags
-    /// </summary>
-    public enum Flag : int
-    {
-        NONE = 0,
-
-        // Boolean flags
-        Progress,
-        Size,
-
-        // Int64 flags
-        BlockSize,
-        Count,
-        Seek,
-        Skip,
-
-        // String flags
-        Filter,
-        InputFile,
-        OutputFile,
-    }
-}

MPF.Library/DD/Parameters.cs

@@ -1,10 +1,8 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using MPF.Data;
-using MPF.Utilities;
 
 namespace MPF.DD
 {
@@ -16,7 +14,7 @@ namespace MPF.DD
         #region Generic Dumping Information
 
         /// <inheritdoc/>
-        public override string InputPath => InputFileValue;
+        public override string InputPath => InputFileValue?.TrimStart('\\', '?');
 
         /// <inheritdoc/>
         public override string OutputPath => OutputFileValue;
@@ -33,36 +31,11 @@ namespace MPF.DD
 
         #region Metadata
 
-        /// <summary>
-        /// Base command to run
-        /// </summary>
-        public Command BaseCommand { get; set; }
-
         /// <inheritdoc/>
         public override InternalProgram InternalProgram => InternalProgram.DD;
 
         #endregion
 
-        /// <summary>
-        /// Set of flags to pass to the executable
-        /// </summary>
-        protected Dictionary<Flag, bool?> _flags = new Dictionary<Flag, bool?>();
-        public bool? this[Flag key]
-        {
-            get
-            {
-                if (_flags.ContainsKey(key))
-                    return _flags[key];
-
-                return null;
-            }
-            set
-            {
-                _flags[key] = value;
-            }
-        }
-        protected internal IEnumerable<Flag> Keys => _flags.Keys;
-
         #region Flag Values
 
         public long? BlockSizeValue { get; set; }
@@ -161,23 +134,26 @@ namespace MPF.DD
         {
             List<string> parameters = new List<string>();
 
-            if (BaseCommand != Command.NONE)
-                parameters.Add(Converters.LongName(BaseCommand));
+            if (BaseCommand == null)
+                BaseCommand = CommandStrings.NONE;
+
+            if (!string.IsNullOrEmpty(BaseCommand))
+                parameters.Add(BaseCommand);
 
             #region Boolean flags
 
             // Progress
-            if (GetSupportedCommands(Flag.Progress).Contains(BaseCommand))
+            if (IsFlagSupported(FlagStrings.Progress))
             {
-                if (this[Flag.Progress] == true)
-                    parameters.Add($"{this[Flag.Progress]}");
+                if (this[FlagStrings.Progress] == true)
+                    parameters.Add($"{FlagStrings.Progress}");
             }
 
             // Size
-            if (GetSupportedCommands(Flag.Size).Contains(BaseCommand))
+            if (IsFlagSupported(FlagStrings.Size))
             {
-                if (this[Flag.Size] == true)
-                    parameters.Add($"{this[Flag.Size]}");
+                if (this[FlagStrings.Size] == true)
+                    parameters.Add($"{FlagStrings.Size}");
             }
 
             #endregion
@@ -185,31 +161,31 @@ namespace MPF.DD
             #region Int64 flags
 
             // Block Size
-            if (GetSupportedCommands(Flag.BlockSize).Contains(BaseCommand))
+            if (IsFlagSupported(FlagStrings.BlockSize))
             {
-                if (this[Flag.BlockSize] == true && BlockSizeValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.BlockSize)}={BlockSizeValue}");
+                if (this[FlagStrings.BlockSize] == true && BlockSizeValue != null)
+                    parameters.Add($"{FlagStrings.BlockSize}={BlockSizeValue}");
             }
 
             // Count
-            if (GetSupportedCommands(Flag.Count).Contains(BaseCommand))
+            if (IsFlagSupported(FlagStrings.Count))
             {
-                if (this[Flag.Count] == true && CountValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.Count)}={CountValue}");
+                if (this[FlagStrings.Count] == true && CountValue != null)
+                    parameters.Add($"{FlagStrings.Count}={CountValue}");
             }
 
             // Seek
-            if (GetSupportedCommands(Flag.Seek).Contains(BaseCommand))
+            if (IsFlagSupported(FlagStrings.Seek))
             {
-                if (this[Flag.Seek] == true && SeekValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.Seek)}={SeekValue}");
+                if (this[FlagStrings.Seek] == true && SeekValue != null)
+                    parameters.Add($"{FlagStrings.Seek}={SeekValue}");
             }
 
             // Skip
-            if (GetSupportedCommands(Flag.Skip).Contains(BaseCommand))
+            if (IsFlagSupported(FlagStrings.Skip))
             {
-                if (this[Flag.Skip] == true && SkipValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.Skip)}={SkipValue}");
+                if (this[FlagStrings.Skip] == true && SkipValue != null)
+                    parameters.Add($"{FlagStrings.Skip}={SkipValue}");
             }
 
             #endregion
@@ -217,33 +193,57 @@ namespace MPF.DD
             #region String flags
 
             // Filter
-            if (GetSupportedCommands(Flag.Filter).Contains(BaseCommand))
+            if (IsFlagSupported(FlagStrings.Filter))
             {
-                if (this[Flag.Filter] == true && FilterValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.Filter)}={FilterValue}");
+                if (this[FlagStrings.Filter] == true && FilterValue != null)
+                    parameters.Add($"{FlagStrings.Filter}={FilterValue}");
             }
 
             // Input File
-            if (GetSupportedCommands(Flag.InputFile).Contains(BaseCommand))
+            if (IsFlagSupported(FlagStrings.InputFile))
             {
-                if (this[Flag.InputFile] == true && InputFileValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.InputFile)}={InputFileValue}");
+                if (this[FlagStrings.InputFile] == true && InputFileValue != null)
+                    parameters.Add($"{FlagStrings.InputFile}=\"{InputFileValue}\"");
                 else
                     return null;
             }
 
             // Output File
-            if (GetSupportedCommands(Flag.OutputFile).Contains(BaseCommand))
+            if (IsFlagSupported(FlagStrings.OutputFile))
             {
-                if (this[Flag.OutputFile] == true && OutputFileValue != null)
-                    parameters.Add($"{Converters.LongName(Flag.OutputFile)}={OutputFileValue}");
+                if (this[FlagStrings.OutputFile] == true && OutputFileValue != null)
+                    parameters.Add($"{FlagStrings.OutputFile}=\"{OutputFileValue}\"");
                 else
                     return null;
             }
 
             #endregion
 
-            return string.Empty;
+            return string.Join(" ", parameters);
+        }
+
+        /// <inheritdoc/>
+        public override Dictionary<string, List<string>> GetCommandSupport()
+        {
+            return new Dictionary<string, List<string>>()
+            {
+                [CommandStrings.NONE] = new List<string>()
+                {
+                    FlagStrings.BlockSize,
+                    FlagStrings.Count,
+                    FlagStrings.Filter,
+                    FlagStrings.InputFile,
+                    FlagStrings.OutputFile,
+                    FlagStrings.Progress,
+                    FlagStrings.Seek,
+                    FlagStrings.Size,
+                    FlagStrings.Skip,
+                },
+
+                [CommandStrings.List] = new List<string>()
+                {
+                },
+            };
         }
 
         /// <inheritdoc/>
@@ -254,7 +254,7 @@ namespace MPF.DD
         {
             switch (this.BaseCommand)
             {
-                case Command.List:
+                case CommandStrings.List:
                     return false;
                 default:
                     return true;
@@ -264,9 +264,9 @@ namespace MPF.DD
         /// <inheritdoc/>
         protected override void ResetValues()
         {
-            BaseCommand = Command.NONE;
+            BaseCommand = CommandStrings.NONE;
 
-            _flags = new Dictionary<Flag, bool?>();
+            flags = new Dictionary<string, bool?>();
 
             BlockSizeValue = null;
             CountValue = null;
@@ -279,16 +279,16 @@ namespace MPF.DD
         /// <inheritdoc/>
         protected override void SetDefaultParameters(char driveLetter, string filename, int? driveSpeed, Options options)
         {
-            BaseCommand = Command.NONE;
+            BaseCommand = CommandStrings.NONE;
 
-            this[Flag.InputFile] = true;
+            this[FlagStrings.InputFile] = true;
             InputFileValue = $"\\\\?\\{driveLetter}:";
 
-            this[Flag.OutputFile] = true;
+            this[FlagStrings.OutputFile] = true;
             OutputFileValue = filename;
 
             // TODO: Add more common block sizes
-            this[Flag.BlockSize] = true;
+            this[FlagStrings.BlockSize] = true;
             switch (this.Type)
             {
                 case MediaType.FloppyDisk:
@@ -300,13 +300,15 @@ namespace MPF.DD
                     break;
             }
 
-            this[Flag.Progress] = true;
-            this[Flag.Size] = true;
+            this[FlagStrings.Progress] = true;
+            this[FlagStrings.Size] = true;
         }
 
         /// <inheritdoc/>
         protected override bool ValidateAndSetParameters(string parameters)
         {
+            BaseCommand = CommandStrings.NONE;
+
             // The string has to be valid by itself first
             if (string.IsNullOrWhiteSpace(parameters))
                 return false;
@@ -321,13 +323,14 @@ namespace MPF.DD
 
             // Determine what the commandline should look like given the first item
             int start = 0;
-            BaseCommand = Converters.StringToCommand(parts[0]);
-            if (BaseCommand != Command.NONE)
+            if (parts[0] == CommandStrings.List)
+            {
+                BaseCommand = parts[0];
                 start = 1;
+            }
 
             // Loop through all auxilary flags, if necessary
-            int i = 0;
-            for (i = start; i < parts.Count; i++)
+            for (int i = start; i < parts.Count; i++)
             {
                 // Flag read-out values
                 long? longValue = null;
@@ -339,41 +342,33 @@ namespace MPF.DD
                 #region Boolean flags
 
                 // Progress
-                ProcessBooleanParameter(parts, FlagStrings.Progress, Flag.Progress, ref i);
+                ProcessFlagParameter(parts, FlagStrings.Progress, ref i);
 
                 // Size
-                ProcessBooleanParameter(parts, FlagStrings.Size, Flag.Size, ref i);
+                ProcessFlagParameter(parts, FlagStrings.Size, ref i);
 
                 #endregion
 
                 #region Int64 flags
 
                 // Block Size
-                longValue = ProcessInt64Parameter(parts, FlagStrings.BlockSize, Flag.BlockSize, ref i);
-                if (longValue == Int64.MinValue)
-                    return false;
-                else if (longValue != null)
+                longValue = ProcessInt64Parameter(parts, FlagStrings.BlockSize, ref i);
+                if (longValue != null)
                     BlockSizeValue = longValue;
 
                 // Count
-                longValue = ProcessInt64Parameter(parts, FlagStrings.Count, Flag.Count, ref i);
-                if (longValue == Int64.MinValue)
-                    return false;
-                else if (longValue != null)
+                longValue = ProcessInt64Parameter(parts, FlagStrings.Count, ref i);
+                if (longValue != null)
                     CountValue = longValue;
 
                 // Seek
-                longValue = ProcessInt64Parameter(parts, FlagStrings.Seek, Flag.Seek, ref i);
-                if (longValue == Int64.MinValue)
-                    return false;
-                else if (longValue != null)
+                longValue = ProcessInt64Parameter(parts, FlagStrings.Seek, ref i);
+                if (longValue != null)
                     SeekValue = longValue;
 
                 // Skip
-                longValue = ProcessInt64Parameter(parts, FlagStrings.Skip, Flag.Skip, ref i);
-                if (longValue == Int64.MinValue)
-                    return false;
-                else if (longValue != null)
+                longValue = ProcessInt64Parameter(parts, FlagStrings.Skip, ref i);
+                if (longValue != null)
                     SkipValue = longValue;
 
                 #endregion
@@ -381,22 +376,18 @@ namespace MPF.DD
                 #region String flags
 
                 // Filter (fixed, removable, disk, partition)
-                stringValue = ProcessStringParameter(parts, FlagStrings.Filter, Flag.Filter, ref i);
+                stringValue = ProcessStringParameter(parts, FlagStrings.Filter, ref i);
                 if (!string.IsNullOrEmpty(stringValue))
                     FilterValue = stringValue;
 
                 // Input File
-                stringValue = ProcessStringParameter(parts, FlagStrings.InputFile, Flag.InputFile, ref i);
-                if (string.Equals(stringValue, string.Empty))
-                    return false;
-                else if (stringValue != null)
+                stringValue = ProcessStringParameter(parts, FlagStrings.InputFile, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
                     InputFileValue = stringValue;
 
                 // Output File
-                stringValue = ProcessStringParameter(parts, FlagStrings.OutputFile, Flag.OutputFile, ref i);
-                if (string.Equals(stringValue, string.Empty))
-                    return false;
-                else if (stringValue != null)
+                stringValue = ProcessStringParameter(parts, FlagStrings.OutputFile, ref i);
+                if (!string.IsNullOrEmpty(stringValue))
                     OutputFileValue = stringValue;
 
                 #endregion
@@ -406,212 +397,5 @@ namespace MPF.DD
         }
 
         #endregion
-
-        #region Private Extra Methods
-
-        /// <summary>
-        /// Get the list of commands that use a given flag
-        /// </summary>
-        /// <param name="flag">Flag value to get commands for</param>
-        /// <returns>List of Commands, if possible</returns>
-        private static List<Command> GetSupportedCommands(Flag flag)
-        {
-            var commands = new List<Command>();
-            switch (flag)
-            {
-                #region Boolean flags
-
-                case Flag.Progress:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.Size:
-                    commands.Add(Command.NONE);
-                    break;
-
-                #endregion
-
-                #region Int64 flags
-
-                case Flag.BlockSize:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.Count:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.Seek:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.Skip:
-                    commands.Add(Command.NONE);
-                    break;
-
-                #endregion
-
-                #region String flags
-
-                case Flag.Filter:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.InputFile:
-                    commands.Add(Command.NONE);
-                    break;
-                case Flag.OutputFile:
-                    commands.Add(Command.NONE);
-                    break;
-
-                #endregion
-
-                case Flag.NONE:
-                default:
-                    return commands;
-            }
-
-            return commands;
-        }
-
-        #endregion
-
-        #region Process Parameter Helpers
-
-        /// <summary>
-        /// Process a boolean parameter
-        /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
-        /// <param name="flagString">Flag string to check</param>
-        /// <param name="flag">Flag value corresponding to the flag</param>
-        /// <param name="i">Reference to the position in the parts</param>
-        /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
-        private bool ProcessBooleanParameter(List<string> parts, string flagString, Flag flag, ref int i)
-        {
-            if (parts == null)
-                return false;
-
-            if (parts[i] == flagString)
-            {
-                if (!GetSupportedCommands(flag).Contains(BaseCommand))
-                    return false;
-
-                this[flag] = true;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Process an Int64 parameter
-        /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
-        /// <param name="flagString">Flag string to check</param>
-        /// <param name="flag">Flag value corresponding to the flag</param>
-        /// <param name="i">Reference to the position in the parts</param>
-        /// <returns>Int64 value if success, Int64.MinValue if skipped, null on error/returns>
-        private long? ProcessInt64Parameter(List<string> parts, string flagString, Flag flag, ref int i)
-        {
-            if (parts == null)
-                return null;
-
-            if (parts[i].StartsWith(flagString))
-            {
-                if (!GetSupportedCommands(flag).Contains(BaseCommand))
-                    return null;
-
-                string[] commandParts = parts[i].Split('=');
-                if (commandParts.Length != 2)
-                    return null;
-
-                string valuePart = commandParts[1];
-                long factor = 1;
-
-                // Characters
-                if (valuePart.EndsWith("c", StringComparison.Ordinal))
-                {
-                    factor = 1;
-                    valuePart.TrimEnd('c');
-                }
-
-                // Words
-                else if (valuePart.EndsWith("w", StringComparison.Ordinal))
-                {
-                    factor = 2;
-                    valuePart.TrimEnd('w');
-                }
-
-                // Double Words
-                else if (valuePart.EndsWith("d", StringComparison.Ordinal))
-                {
-                    factor = 4;
-                    valuePart.TrimEnd('d');
-                }
-
-                // Quad Words
-                else if (valuePart.EndsWith("q", StringComparison.Ordinal))
-                {
-                    factor = 8;
-                    valuePart.TrimEnd('q');
-                }
-
-                // Kilobytes
-                else if (valuePart.EndsWith("k", StringComparison.Ordinal))
-                {
-                    factor = 1024;
-                    valuePart.TrimEnd('k');
-                }
-
-                // Megabytes
-                else if (valuePart.EndsWith("M", StringComparison.Ordinal))
-                {
-                    factor = 1024 * 1024;
-                    valuePart.TrimEnd('M');
-                }
-
-                // Gigabytes
-                else if (valuePart.EndsWith("G", StringComparison.Ordinal))
-                {
-                    factor = 1024 * 1024 * 1024;
-                    valuePart.TrimEnd('G');
-                }
-
-                if (!IsValidInt64(valuePart))
-                    return null;
-
-                this[flag] = true;
-                return long.Parse(valuePart) * factor;
-            }
-
-            return Int64.MinValue;
-        }
-
-        /// <summary>
-        /// Process a string parameter
-        /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
-        /// <param name="flagString">Flag string to check</param>
-        /// <param name="flag">Flag value corresponding to the flag</param>
-        /// <param name="i">Reference to the position in the parts</param>
-        /// <returns>String value if possible, string.Empty on missing, null on error</returns>
-        private string ProcessStringParameter(List<string> parts, string flagString, Flag flag, ref int i)
-        {
-            if (parts == null)
-                return null;
-
-            if (parts[i] == flagString)
-            {
-                if (!GetSupportedCommands(flag).Contains(BaseCommand))
-                    return null;
-
-                string[] commandParts = parts[i].Split('=');
-                if (commandParts.Length != 2)
-                    return null;
-
-                string valuePart = commandParts[1];
-
-                this[flag] = true;
-                return valuePart.Trim('"');
-            }
-
-            return string.Empty;
-        }
-
-        #endregion
     }
 }

MPF.Library/Data/BaseParameters.cs

@@ -34,6 +34,49 @@ namespace MPF.Data
 
         #region Generic Dumping Information
 
+        /// <summary>
+        /// Base command to run
+        /// </summary>
+        public string BaseCommand { get; set; }
+
+        /// <summary>
+        /// Set of flags to pass to the executable
+        /// </summary>
+        protected Dictionary<string, bool?> flags = new Dictionary<string, bool?>();
+        protected internal IEnumerable<string> Keys => flags.Keys;
+
+        /// <summary>
+        /// Safe access to currently set flags
+        /// </summary>
+        public bool? this[string key]
+        {
+            get
+            {
+                if (flags.ContainsKey(key))
+                    return flags[key];
+
+                return null;
+            }
+            set
+            {
+                flags[key] = value;
+            }
+        }
+
+        /// <summary>
+        /// Process to track external program
+        /// </summary>
+        private Process process;
+
+        #endregion
+
+        #region Virtual Dumping Information
+
+        /// <summary>
+        /// Command to flag support mappings
+        /// </summary>
+        public Dictionary<string, List<string>> CommandSupport => GetCommandSupport();
+
         /// <summary>
         /// Input path for operations
         /// </summary>
@@ -50,11 +93,6 @@ namespace MPF.Data
         /// </summary>
         public virtual int? Speed { get; set; } = null;
 
-        /// <summary>
-        /// Process to track external program
-        /// </summary>
-        private Process process;
-
         #endregion
 
         #region Metadata
@@ -130,6 +168,12 @@ namespace MPF.Data
 
         #region Virtual Methods
 
+        /// <summary>
+        /// Get all commands mapped to the supported flags
+        /// </summary>
+        /// <returns>Mappings from command to supported flags</returns>
+        public virtual Dictionary<string, List<string>> GetCommandSupport() => null;
+
         /// <summary>
         /// Blindly generate a parameter string based on the inputs
         /// </summary>
@@ -162,6 +206,22 @@ namespace MPF.Data
         /// <returns>True if it's a dumping command, false otherwise</returns>
         public virtual bool IsDumpingCommand() => true;
 
+        /// <summary>
+        /// Gets if the flag is supported by the current command
+        /// </summary>
+        /// <param name="flag">Flag value to check</param>
+        /// <returns>True if the flag value is supported, false otherwise</returns>
+        public virtual bool IsFlagSupported(string flag)
+        {
+            if (CommandSupport == null)
+                return false;
+            if (this.BaseCommand == null)
+                return false;
+            if (!CommandSupport.ContainsKey(this.BaseCommand))
+                return false;
+            return CommandSupport[this.BaseCommand].Contains(flag);
+        }
+
         /// <summary>
         /// Returns if the current Parameter object is valid
         /// </summary>
@@ -311,7 +371,10 @@ namespace MPF.Data
         /// <returns>True if it's a flag, false otherwise</returns>
         protected static bool IsFlag(string parameter)
         {
-            if (parameter.Trim('\"').StartsWith("/"))
+            parameter = parameter.Trim('\"');
+            if (parameter.StartsWith("/"))
+                return true;
+            else if (parameter.StartsWith("-"))
                 return true;
 
             return false;
@@ -349,7 +412,8 @@ namespace MPF.Data
         /// <returns>True if it's a valid byte, false otherwise</returns>
         protected static bool IsValidInt8(string parameter, sbyte lowerBound = -1, sbyte upperBound = -1)
         {
-            if (!sbyte.TryParse(parameter, out sbyte temp))
+            (string value, long _) = ExtractFactorFromValue(parameter);
+            if (!sbyte.TryParse(value, out sbyte temp))
                 return false;
             else if (lowerBound != -1 && temp < lowerBound)
                 return false;
@@ -368,7 +432,8 @@ namespace MPF.Data
         /// <returns>True if it's a valid Int16, false otherwise</returns>
         protected static bool IsValidInt16(string parameter, short lowerBound = -1, short upperBound = -1)
         {
-            if (!short.TryParse(parameter, out short temp))
+            (string value, long _) = ExtractFactorFromValue(parameter);
+            if (!short.TryParse(value, out short temp))
                 return false;
             else if (lowerBound != -1 && temp < lowerBound)
                 return false;
@@ -387,7 +452,8 @@ namespace MPF.Data
         /// <returns>True if it's a valid Int32, false otherwise</returns>
         protected static bool IsValidInt32(string parameter, int lowerBound = -1, int upperBound = -1)
         {
-            if (!int.TryParse(parameter, out int temp))
+            (string value, long _) = ExtractFactorFromValue(parameter);
+            if (!int.TryParse(value, out int temp))
                 return false;
             else if (lowerBound != -1 && temp < lowerBound)
                 return false;
@@ -406,7 +472,8 @@ namespace MPF.Data
         /// <returns>True if it's a valid Int64, false otherwise</returns>
         protected static bool IsValidInt64(string parameter, long lowerBound = -1, long upperBound = -1)
         {
-            if (!long.TryParse(parameter, out long temp))
+            (string value, long _) = ExtractFactorFromValue(parameter);
+            if (!long.TryParse(value, out long temp))
                 return false;
             else if (lowerBound != -1 && temp < lowerBound)
                 return false;
@@ -416,6 +483,571 @@ namespace MPF.Data
             return true;
         }
 
+        /// <summary>
+        /// Process a flag parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="flagString">Flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
+        protected bool ProcessFlagParameter(List<string> parts, string flagString, ref int i)
+        {
+            return ProcessFlagParameter(parts, null, flagString, ref i);
+        }
+
+        /// <summary>
+        /// Process a flag parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="shortFlagString">Short flag string, if available</param>
+        /// <param name="longFlagString">Long flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
+        protected bool ProcessFlagParameter(List<string> parts, string shortFlagString, string longFlagString, ref int i)
+        {
+            if (parts == null)
+                return false;
+
+            if (parts[i] == shortFlagString || parts[i] == longFlagString)
+            {
+                if (!IsFlagSupported(longFlagString))
+                    return false;
+
+                this[longFlagString] = true;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Process a boolean parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="flagString">Flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
+        protected bool ProcessBooleanParameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        {
+            return ProcessBooleanParameter(parts, null, flagString, ref i, missingAllowed);
+        }
+
+        /// <summary>
+        /// Process a boolean parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="shortFlagString">Short flag string, if available</param>
+        /// <param name="longFlagString">Long flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
+        protected bool ProcessBooleanParameter(List<string> parts, string shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        {
+            if (parts == null)
+                return false;
+
+            if (parts[i] == shortFlagString || parts[i] == longFlagString)
+            {
+                if (!IsFlagSupported(longFlagString))
+                {
+                    return false;
+                }
+                else if (!DoesExist(parts, i + 1))
+                {
+                    if (missingAllowed)
+                    {
+                        this[longFlagString] = true;
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                else if (IsFlag(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                    {
+                        this[longFlagString] = true;
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+                else if (!IsValidBool(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                    {
+                        this[longFlagString] = true;
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+
+                this[longFlagString] = bool.Parse(parts[i + 1]);
+                i++;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Process a sbyte parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="flagString">Flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>SByte value if success, SByte.MinValue if skipped, null on error/returns>
+        protected sbyte? ProcessInt8Parameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        {
+            return ProcessInt8Parameter(parts, null, flagString, ref i, missingAllowed);
+        }
+
+        /// <summary>
+        /// Process an sbyte parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="shortFlagString">Short flag string, if available</param>
+        /// <param name="longFlagString">Long flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>SByte value if success, SByte.MinValue if skipped, null on error/returns>
+        protected sbyte? ProcessInt8Parameter(List<string> parts, string shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        {
+            if (parts == null)
+                return null;
+
+            if (parts[i] == shortFlagString || parts[i] == longFlagString)
+            {
+                if (!IsFlagSupported(longFlagString))
+                {
+                    return null;
+                }
+                else if (!DoesExist(parts, i + 1))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+                else if (IsFlag(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+                else if (!IsValidInt8(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+
+                this[longFlagString] = true;
+                i++;
+
+                (string value, long factor) = ExtractFactorFromValue(parts[i]);
+                return (sbyte)(sbyte.Parse(value) * factor);
+            }
+            else if (parts[i].StartsWith(shortFlagString + "=") || parts[i].StartsWith(longFlagString + "="))
+            {
+                if (!IsFlagSupported(longFlagString))
+                    return null;
+
+                string[] commandParts = parts[i].Split('=');
+                if (commandParts.Length != 2)
+                    return null;
+
+                string valuePart = commandParts[1];
+
+                (string value, long factor) = ExtractFactorFromValue(valuePart);
+                return (sbyte)(sbyte.Parse(value) * factor);
+            }
+
+            return SByte.MinValue;
+        }
+
+        /// <summary>
+        /// Process an Int16 parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="flagString">Flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>Int16 value if success, Int16.MinValue if skipped, null on error/returns>
+        protected short? ProcessInt16Parameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        {
+            return ProcessInt16Parameter(parts, null, flagString, ref i, missingAllowed);
+        }
+
+        /// <summary>
+        /// Process an Int16 parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="shortFlagString">Short flag string, if available</param>
+        /// <param name="longFlagString">Long flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>Int16 value if success, Int16.MinValue if skipped, null on error/returns>
+        protected short? ProcessInt16Parameter(List<string> parts, string shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        {
+            if (parts == null)
+                return null;
+
+            if (parts[i] == shortFlagString || parts[i] == longFlagString)
+            {
+                if (!IsFlagSupported(longFlagString))
+                {
+                    return null;
+                }
+                else if (!DoesExist(parts, i + 1))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+                else if (IsFlag(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+                else if (!IsValidInt16(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+
+                this[longFlagString] = true;
+                i++;
+                (string value, long factor) = ExtractFactorFromValue(parts[i]);
+                return (short)(short.Parse(value) * factor);
+            }
+            else if (parts[i].StartsWith(shortFlagString + "=") || parts[i].StartsWith(longFlagString + "="))
+            {
+                if (!IsFlagSupported(longFlagString))
+                    return null;
+
+                string[] commandParts = parts[i].Split('=');
+                if (commandParts.Length != 2)
+                    return null;
+
+                string valuePart = commandParts[1];
+
+                (string value, long factor) = ExtractFactorFromValue(valuePart);
+                return (short)(short.Parse(value) * factor);
+            }
+
+            return Int16.MinValue;
+        }
+
+        /// <summary>
+        /// Process an Int32 parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="flagString">Flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>Int32 value if success, Int32.MinValue if skipped, null on error/returns>
+        protected int? ProcessInt32Parameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        {
+            return ProcessInt32Parameter(parts, null, flagString, ref i, missingAllowed);
+        }
+
+        /// <summary>
+        /// Process an Int32 parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="shortFlagString">Short flag string, if available</param>
+        /// <param name="longFlagString">Long flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>Int32 value if success, Int32.MinValue if skipped, null on error/returns>
+        protected int? ProcessInt32Parameter(List<string> parts, string shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        {
+            if (parts == null)
+                return null;
+
+            if (parts[i] == shortFlagString || parts[i] == longFlagString)
+            {
+                if (!IsFlagSupported(longFlagString))
+                {
+                    return null;
+                }
+                else if (!DoesExist(parts, i + 1))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+                else if (IsFlag(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+                else if (!IsValidInt32(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+
+                this[longFlagString] = true;
+                i++;
+                (string value, long factor) = ExtractFactorFromValue(parts[i]);
+                return (int)(int.Parse(value) * factor);
+            }
+            else if (parts[i].StartsWith(shortFlagString + "=") || parts[i].StartsWith(longFlagString + "="))
+            {
+                if (!IsFlagSupported(longFlagString))
+                    return null;
+
+                string[] commandParts = parts[i].Split('=');
+                if (commandParts.Length != 2)
+                    return null;
+
+                string valuePart = commandParts[1];
+
+                (string value, long factor) = ExtractFactorFromValue(valuePart);
+                return (int)(int.Parse(value) * factor);
+            }
+
+            return Int32.MinValue;
+        }
+
+        /// <summary>
+        /// Process an Int64 parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="flagString">Flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>Int64 value if success, Int64.MinValue if skipped, null on error/returns>
+        protected long? ProcessInt64Parameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        {
+            return ProcessInt64Parameter(parts, null, flagString, ref i, missingAllowed);
+        }
+
+        /// <summary>
+        /// Process an Int64 parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="shortFlagString">Short flag string, if available</param>
+        /// <param name="longFlagString">Long flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>Int64 value if success, Int64.MinValue if skipped, null on error/returns>
+        protected long? ProcessInt64Parameter(List<string> parts, string shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        {
+            if (parts == null)
+                return null;
+
+            if (parts[i] == shortFlagString || parts[i] == longFlagString)
+            {
+                if (!IsFlagSupported(longFlagString))
+                {
+                    return null;
+                }
+                else if (!DoesExist(parts, i + 1))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+                else if (IsFlag(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+                else if (!IsValidInt64(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+
+                this[longFlagString] = true;
+                i++;
+                (string value, long factor) = ExtractFactorFromValue(parts[i]);
+                return long.Parse(value) * factor;
+            }
+            else if (parts[i].StartsWith(shortFlagString + "=") || parts[i].StartsWith(longFlagString + "="))
+            {
+                if (!IsFlagSupported(longFlagString))
+                    return null;
+
+                string[] commandParts = parts[i].Split('=');
+                if (commandParts.Length != 2)
+                    return null;
+
+                string valuePart = commandParts[1];
+
+                (string value, long factor) = ExtractFactorFromValue(valuePart);
+                return long.Parse(value) * factor;
+            }
+
+            return Int64.MinValue;
+        }
+
+        /// <summary>
+        /// Process an Int64 parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="flagString">Flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>String value if possible, string.Empty on missing, null on error</returns>
+        protected string ProcessStringParameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        {
+            return ProcessStringParameter(parts, null, flagString, ref i, missingAllowed);
+        }
+
+        /// <summary>
+        /// Process a string parameter
+        /// </summary>
+        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="shortFlagString">Short flag string, if available</param>
+        /// <param name="longFlagString">Long flag string, if available</param>
+        /// <param name="i">Reference to the position in the parts</param>
+        /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
+        /// <returns>String value if possible, string.Empty on missing, null on error</returns>
+        protected string ProcessStringParameter(List<string> parts, string shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        {
+            if (parts == null)
+                return null;
+
+            if (parts[i] == shortFlagString || parts[i] == longFlagString)
+            {
+                if (!IsFlagSupported(longFlagString))
+                {
+                    return null;
+                }
+                else if (!DoesExist(parts, i + 1))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+                else if (IsFlag(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+                else if (string.IsNullOrWhiteSpace(parts[i + 1]))
+                {
+                    if (missingAllowed)
+                        this[longFlagString] = true;
+
+                    return null;
+                }
+
+                this[longFlagString] = true;
+                i++;
+                return parts[i].Trim('"');
+            }
+            else if (parts[i].StartsWith(shortFlagString + "=") || parts[i].StartsWith(longFlagString + "="))
+            {
+                if (!IsFlagSupported(longFlagString))
+                    return null;
+
+                string[] commandParts = parts[i].Split('=');
+                if (commandParts.Length != 2)
+                    return null;
+
+                string valuePart = commandParts[1];
+
+                this[longFlagString] = true;
+                return valuePart.Trim('"');
+            }
+
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Get yhe trimmed value and multiplication factor from a value
+        /// </summary>
+        /// <param name="value">String value to treat as suffixed number</param>
+        /// <returns>Trimmed value and multiplication factor</returns>
+        private static (string trimmed, long factor) ExtractFactorFromValue(string value)
+        {
+            value = value.Trim('"');
+            long factor = 1;
+
+            // Characters
+            if (value.EndsWith("c", StringComparison.Ordinal))
+            {
+                factor = 1;
+                value = value.TrimEnd('c');
+            }
+
+            // Words
+            else if (value.EndsWith("w", StringComparison.Ordinal))
+            {
+                factor = 2;
+                value = value.TrimEnd('w');
+            }
+
+            // Double Words
+            else if (value.EndsWith("d", StringComparison.Ordinal))
+            {
+                factor = 4;
+                value = value.TrimEnd('d');
+            }
+
+            // Quad Words
+            else if (value.EndsWith("q", StringComparison.Ordinal))
+            {
+                factor = 8;
+                value = value.TrimEnd('q');
+            }
+
+            // Kilobytes
+            else if (value.EndsWith("k", StringComparison.Ordinal))
+            {
+                factor = 1024;
+                value = value.TrimEnd('k');
+            }
+
+            // Megabytes
+            else if (value.EndsWith("M", StringComparison.Ordinal))
+            {
+                factor = 1024 * 1024;
+                value = value.TrimEnd('M');
+            }
+
+            // Gigabytes
+            else if (value.EndsWith("G", StringComparison.Ordinal))
+            {
+                factor = 1024 * 1024 * 1024;
+                value = value.TrimEnd('G');
+            }
+
+            return (value, factor);
+        }
+
         #endregion
 
         #region Common Information Extraction

MPF.Library/Data/DumpEnvironment.cs

@@ -320,7 +320,7 @@ namespace MPF.Data
 
             var parameters = new DiscImageCreator.Parameters(string.Empty)
             {
-                BaseCommand = DiscImageCreator.Command.Eject,
+                BaseCommand = DiscImageCreator.CommandStrings.Eject,
                 DriveLetter = Drive.Letter.ToString(),
                 ExecutablePath = Options.DiscImageCreatorPath,
             };
@@ -350,7 +350,7 @@ namespace MPF.Data
 
             DiscImageCreator.Parameters parameters = new DiscImageCreator.Parameters(string.Empty)
             {
-                BaseCommand = DiscImageCreator.Command.Reset,
+                BaseCommand = DiscImageCreator.CommandStrings.Reset,
                 DriveLetter = Drive.Letter.ToString(),
                 ExecutablePath = Options.DiscImageCreatorPath,
             };

MPF.Library/DiscImageCreator/Constants.cs

@@ -5,6 +5,7 @@ namespace MPF.DiscImageCreator
     /// </summary>
     public static class CommandStrings
     {
+        public const string NONE = "";
         public const string Audio = "audio";
         public const string BluRay = "bd";
         public const string Close = "close";

MPF.Library/DiscImageCreator/Converters.cs

@@ -11,31 +11,31 @@ namespace MPF.DiscImageCreator
         /// </summary>
         /// <param name="baseCommand">Command value to check</param>
         /// <returns>KnownSystem if possible, null on error</returns>
-        public static KnownSystem? ToKnownSystem(Command baseCommand)
+        public static KnownSystem? ToKnownSystem(string baseCommand)
         {
             switch (baseCommand)
             {
-                case Command.Audio:
+                case CommandStrings.Audio:
                     return KnownSystem.AudioCD;
-                case Command.CompactDisc:
-                case Command.Data:
-                case Command.DigitalVideoDisc:
-                case Command.Disk:
-                case Command.Floppy:
-                case Command.Tape:
+                case CommandStrings.CompactDisc:
+                case CommandStrings.Data:
+                case CommandStrings.DigitalVideoDisc:
+                case CommandStrings.Disk:
+                case CommandStrings.Floppy:
+                case CommandStrings.Tape:
                     return KnownSystem.IBMPCCompatible;
-                case Command.GDROM:
-                case Command.Swap:
+                case CommandStrings.GDROM:
+                case CommandStrings.Swap:
                     return KnownSystem.SegaDreamcast;
-                case Command.BluRay:
+                case CommandStrings.BluRay:
                     return KnownSystem.SonyPlayStation3;
-                case Command.SACD:
+                case CommandStrings.SACD:
                     return KnownSystem.SuperAudioCD;
-                case Command.XBOX:
-                case Command.XBOXSwap:
+                case CommandStrings.XBOX:
+                case CommandStrings.XBOXSwap:
                     return KnownSystem.MicrosoftXBOX;
-                case Command.XGD2Swap:
-                case Command.XGD3Swap:
+                case CommandStrings.XGD2Swap:
+                case CommandStrings.XGD3Swap:
                     return KnownSystem.MicrosoftXBOX360;
                 default:
                     return null;
@@ -48,33 +48,33 @@ namespace MPF.DiscImageCreator
         /// <param name="baseCommand">Command value to check</param>
         /// <returns>MediaType if possible, null on error</returns>
         /// <remarks>This takes the "safe" route by assuming the larger of any given format</remarks>
-        public static MediaType? ToMediaType(Command baseCommand)
+        public static MediaType? ToMediaType(string baseCommand)
         {
             switch (baseCommand)
             {
-                case Command.Audio:
-                case Command.CompactDisc:
-                case Command.Data:
-                case Command.SACD:
+                case CommandStrings.Audio:
+                case CommandStrings.CompactDisc:
+                case CommandStrings.Data:
+                case CommandStrings.SACD:
                     return MediaType.CDROM;
-                case Command.GDROM:
-                case Command.Swap:
+                case CommandStrings.GDROM:
+                case CommandStrings.Swap:
                     return MediaType.GDROM;
-                case Command.DigitalVideoDisc:
-                case Command.XBOX:
-                case Command.XBOXSwap:
-                case Command.XGD2Swap:
-                case Command.XGD3Swap:
+                case CommandStrings.DigitalVideoDisc:
+                case CommandStrings.XBOX:
+                case CommandStrings.XBOXSwap:
+                case CommandStrings.XGD2Swap:
+                case CommandStrings.XGD3Swap:
                     return MediaType.DVD;
-                case Command.BluRay:
+                case CommandStrings.BluRay:
                     return MediaType.BluRay;
 
                 // Non-optical
-                case Command.Floppy:
+                case CommandStrings.Floppy:
                     return MediaType.FloppyDisk;
-                case Command.Disk:
+                case CommandStrings.Disk:
                     return MediaType.HardDisk;
-                case Command.Tape:
+                case CommandStrings.Tape:
                     return MediaType.DataCartridge;
                 default:
                     return null;
@@ -120,222 +120,5 @@ namespace MPF.DiscImageCreator
         }
 
         #endregion
-
-        #region Convert to Long Name
-
-        /// <summary>
-        /// Get the string representation of the Command enum values
-        /// </summary>
-        /// <param name="command">Command value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Command command)
-        {
-            switch (command)
-            {
-                case Command.Audio:
-                    return CommandStrings.Audio;
-                case Command.BluRay:
-                    return CommandStrings.BluRay;
-                case Command.Close:
-                    return CommandStrings.Close;
-                case Command.CompactDisc:
-                    return CommandStrings.CompactDisc;
-                case Command.Data:
-                    return CommandStrings.Data;
-                case Command.DigitalVideoDisc:
-                    return CommandStrings.DigitalVideoDisc;
-                case Command.Disk:
-                    return CommandStrings.Disk;
-                case Command.DriveSpeed:
-                    return CommandStrings.DriveSpeed;
-                case Command.Eject:
-                    return CommandStrings.Eject;
-                case Command.Floppy:
-                    return CommandStrings.Floppy;
-                case Command.GDROM:
-                    return CommandStrings.GDROM;
-                case Command.MDS:
-                    return CommandStrings.MDS;
-                case Command.Merge:
-                    return CommandStrings.Merge;
-                case Command.Reset:
-                    return CommandStrings.Reset;
-                case Command.SACD:
-                    return CommandStrings.SACD;
-                case Command.Start:
-                    return CommandStrings.Start;
-                case Command.Stop:
-                    return CommandStrings.Stop;
-                case Command.Sub:
-                    return CommandStrings.Sub;
-                case Command.Swap:
-                    return CommandStrings.Swap;
-                case Command.Tape:
-                    return CommandStrings.Tape;
-                case Command.XBOX:
-                    return CommandStrings.XBOX;
-                case Command.XBOXSwap:
-                    return CommandStrings.XBOXSwap;
-                case Command.XGD2Swap:
-                    return CommandStrings.XGD2Swap;
-                case Command.XGD3Swap:
-                    return CommandStrings.XGD3Swap;
-
-                case Command.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        /// <summary>
-        /// Get the string representation of the Flag enum values
-        /// </summary>
-        /// <param name="command">Flag value to convert</param>
-        /// <returns>String representing the value, if possible</returns>
-        public static string LongName(Flag flag)
-        {
-            switch (flag)
-            {
-                case Flag.AddOffset:
-                    return FlagStrings.AddOffset;
-                case Flag.AMSF:
-                    return FlagStrings.AMSF;
-                case Flag.AtariJaguar:
-                    return FlagStrings.AtariJaguar;
-                case Flag.BEOpcode:
-                    return FlagStrings.BEOpcode;
-                case Flag.C2Opcode:
-                    return FlagStrings.C2Opcode;
-                case Flag.CopyrightManagementInformation:
-                    return FlagStrings.CopyrightManagementInformation;
-                case Flag.D8Opcode:
-                    return FlagStrings.D8Opcode;
-                case Flag.DisableBeep:
-                    return FlagStrings.DisableBeep;
-                case Flag.ExtractMicroSoftCabFile:
-                    return FlagStrings.ExtractMicroSoftCabFile;
-                case Flag.Fix:
-                    return FlagStrings.Fix;
-                case Flag.ForceUnitAccess:
-                    return FlagStrings.ForceUnitAccess;
-                case Flag.MultiSectorRead:
-                    return FlagStrings.MultiSectorRead;
-                case Flag.MultiSession:
-                    return FlagStrings.MultiSession;
-                case Flag.NoFixSubP:
-                    return FlagStrings.NoFixSubP;
-                case Flag.NoFixSubQ:
-                    return FlagStrings.NoFixSubQ;
-                case Flag.NoFixSubQLibCrypt:
-                    return FlagStrings.NoFixSubQLibCrypt;
-                case Flag.NoFixSubRtoW:
-                    return FlagStrings.NoFixSubRtoW;
-                case Flag.NoFixSubQSecuROM:
-                    return FlagStrings.NoFixSubQSecuROM;
-                case Flag.NoSkipSS:
-                    return FlagStrings.NoSkipSS;
-                case Flag.PadSector:
-                    return FlagStrings.PadSector;
-                case Flag.Raw:
-                    return FlagStrings.Raw;
-                case Flag.Resume:
-                    return FlagStrings.Resume;
-                case Flag.Reverse:
-                    return FlagStrings.Reverse;
-                case Flag.ScanAntiMod:
-                    return FlagStrings.ScanAntiMod;
-                case Flag.ScanFileProtect:
-                    return FlagStrings.ScanFileProtect;
-                case Flag.ScanSectorProtect:
-                    return FlagStrings.ScanSectorProtect;
-                case Flag.SeventyFour:
-                    return FlagStrings.SeventyFour;
-                case Flag.SkipSector:
-                    return FlagStrings.SkipSector;
-                case Flag.SubchannelReadLevel:
-                    return FlagStrings.SubchannelReadLevel;
-                case Flag.UseAnchorVolumeDescriptorPointer:
-                    return FlagStrings.UseAnchorVolumeDescriptorPointer;
-                case Flag.VideoNow:
-                    return FlagStrings.VideoNow;
-                case Flag.VideoNowColor:
-                    return FlagStrings.VideoNowColor;
-                case Flag.VideoNowXP:
-                    return FlagStrings.VideoNowXP;
-
-                case Flag.NONE:
-                default:
-                    return "";
-            }
-        }
-
-        #endregion
-
-        #region Convert From String
-
-        /// <summary>
-        /// Get the Command enum value for a given string
-        /// </summary>
-        /// <param name="command">String value to convert</param>
-        /// <returns>Command represented by the string(s), if possible</returns>
-        public static Command StringToCommand(string command)
-        {
-            switch (command)
-            {
-                case CommandStrings.Audio:
-                    return Command.Audio;
-                case CommandStrings.BluRay:
-                    return Command.BluRay;
-                case CommandStrings.Close:
-                    return Command.Close;
-                case CommandStrings.CompactDisc:
-                    return Command.CompactDisc;
-                case CommandStrings.Data:
-                    return Command.Data;
-                case CommandStrings.DigitalVideoDisc:
-                    return Command.DigitalVideoDisc;
-                case CommandStrings.Disk:
-                    return Command.Disk;
-                case CommandStrings.DriveSpeed:
-                    return Command.DriveSpeed;
-                case CommandStrings.Eject:
-                    return Command.Eject;
-                case CommandStrings.Floppy:
-                    return Command.Floppy;
-                case CommandStrings.GDROM:
-                    return Command.GDROM;
-                case CommandStrings.MDS:
-                    return Command.MDS;
-                case CommandStrings.Merge:
-                    return Command.Merge;
-                case CommandStrings.Reset:
-                    return Command.Reset;
-                case CommandStrings.SACD:
-                    return Command.SACD;
-                case CommandStrings.Start:
-                    return Command.Start;
-                case CommandStrings.Stop:
-                    return Command.Stop;
-                case CommandStrings.Sub:
-                    return Command.Sub;
-                case CommandStrings.Swap:
-                    return Command.Swap;
-                case CommandStrings.Tape:
-                    return Command.Tape;
-                case CommandStrings.XBOX:
-                    return Command.XBOX;
-                case CommandStrings.XBOXSwap:
-                    return Command.XBOXSwap;
-                case CommandStrings.XGD2Swap:
-                    return Command.XGD2Swap;
-                case CommandStrings.XGD3Swap:
-                    return Command.XGD3Swap;
-
-                default:
-                    return Command.NONE;
-            }
-        }
-
-        #endregion
     }
 }

MPF.Library/DiscImageCreator/Enumerations.cs

@@ -1,75 +0,0 @@
-namespace MPF.DiscImageCreator
-{
-    /// <summary>
-    /// Supported DiscImageCreator commands
-    /// </summary>
-    public enum Command : int
-    {
-        NONE = 0,
-        Audio,
-        BluRay,
-        Close,
-        CompactDisc,
-        Data,
-        DigitalVideoDisc,
-        Disk,
-        DriveSpeed,
-        Eject,
-        Floppy,
-        GDROM,
-        MDS,
-        Merge,
-        Reset,
-        SACD,
-        Start,
-        Stop,
-        Sub,
-        Swap,
-        Tape,
-        XBOX,
-        XBOXSwap,
-        XGD2Swap,
-        XGD3Swap,
-    }
-
-    /// <summary>
-    /// Supported DiscImageCreator flags
-    /// </summary>
-    public enum Flag : int
-    {
-        NONE = 0,
-        AddOffset,
-        AMSF,
-        AtariJaguar,
-        BEOpcode,
-        C2Opcode,
-        CopyrightManagementInformation,
-        D8Opcode,
-        DisableBeep,
-        ExtractMicroSoftCabFile,
-        Fix,
-        ForceUnitAccess,
-        MultiSectorRead,
-        MultiSession,
-        NoFixSubP,
-        NoFixSubQ,
-        NoFixSubQLibCrypt,
-        NoFixSubRtoW,
-        NoFixSubQSecuROM,
-        NoSkipSS,
-        PadSector,
-        Raw,
-        Resume,
-        Reverse,
-        ScanAntiMod,
-        ScanFileProtect,
-        ScanSectorProtect,
-        SeventyFour,
-        SkipSector,
-        SubchannelReadLevel,
-        UseAnchorVolumeDescriptorPointer,
-        VideoNow,
-        VideoNowColor,
-        VideoNowXP,
-    }
-}

MPF.Library/UmdImageCreator/Parameters.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using MPF.Data;
-using MPF.Utilities;
 
 namespace MPF.UmdImageCreator
 {

MPF.Test/Utilities/ConvertersTest.cs

@@ -15,48 +15,48 @@ namespace MPF.Test.Utilities
         public static IEnumerable<object[]> KnownSystems = KnownSystemComboBoxItem.GenerateElements().Select(e => new object[] { e });
 
         [Theory]
-        [InlineData(DiscImageCreator.Command.Audio, MediaType.CDROM)]
-        [InlineData(DiscImageCreator.Command.BluRay, MediaType.BluRay)]
-        [InlineData(DiscImageCreator.Command.Close, null)]
-        [InlineData(DiscImageCreator.Command.CompactDisc, MediaType.CDROM)]
-        [InlineData(DiscImageCreator.Command.Data, MediaType.CDROM)]
-        [InlineData(DiscImageCreator.Command.DigitalVideoDisc, MediaType.DVD)]
-        [InlineData(DiscImageCreator.Command.Eject, null)]
-        [InlineData(DiscImageCreator.Command.Floppy, MediaType.FloppyDisk)]
-        [InlineData(DiscImageCreator.Command.GDROM, MediaType.GDROM)]
-        [InlineData(DiscImageCreator.Command.MDS, null)]
-        [InlineData(DiscImageCreator.Command.Reset, null)]
-        [InlineData(DiscImageCreator.Command.SACD, MediaType.CDROM)]
-        [InlineData(DiscImageCreator.Command.Start, null)]
-        [InlineData(DiscImageCreator.Command.Stop, null)]
-        [InlineData(DiscImageCreator.Command.Sub, null)]
-        [InlineData(DiscImageCreator.Command.Swap, MediaType.GDROM)]
-        [InlineData(DiscImageCreator.Command.XBOX, MediaType.DVD)]
-        public void BaseCommandToMediaTypeTest(DiscImageCreator.Command command, MediaType? expected)
+        [InlineData(DiscImageCreator.CommandStrings.Audio, MediaType.CDROM)]
+        [InlineData(DiscImageCreator.CommandStrings.BluRay, MediaType.BluRay)]
+        [InlineData(DiscImageCreator.CommandStrings.Close, null)]
+        [InlineData(DiscImageCreator.CommandStrings.CompactDisc, MediaType.CDROM)]
+        [InlineData(DiscImageCreator.CommandStrings.Data, MediaType.CDROM)]
+        [InlineData(DiscImageCreator.CommandStrings.DigitalVideoDisc, MediaType.DVD)]
+        [InlineData(DiscImageCreator.CommandStrings.Eject, null)]
+        [InlineData(DiscImageCreator.CommandStrings.Floppy, MediaType.FloppyDisk)]
+        [InlineData(DiscImageCreator.CommandStrings.GDROM, MediaType.GDROM)]
+        [InlineData(DiscImageCreator.CommandStrings.MDS, null)]
+        [InlineData(DiscImageCreator.CommandStrings.Reset, null)]
+        [InlineData(DiscImageCreator.CommandStrings.SACD, MediaType.CDROM)]
+        [InlineData(DiscImageCreator.CommandStrings.Start, null)]
+        [InlineData(DiscImageCreator.CommandStrings.Stop, null)]
+        [InlineData(DiscImageCreator.CommandStrings.Sub, null)]
+        [InlineData(DiscImageCreator.CommandStrings.Swap, MediaType.GDROM)]
+        [InlineData(DiscImageCreator.CommandStrings.XBOX, MediaType.DVD)]
+        public void BaseCommandToMediaTypeTest(string command, MediaType? expected)
         {
             MediaType? actual = DiscImageCreator.Converters.ToMediaType(command);
             Assert.Equal(expected, actual);
         }
 
         [Theory]
-        [InlineData(DiscImageCreator.Command.Audio, KnownSystem.AudioCD)]
-        [InlineData(DiscImageCreator.Command.BluRay, KnownSystem.SonyPlayStation3)]
-        [InlineData(DiscImageCreator.Command.Close, null)]
-        [InlineData(DiscImageCreator.Command.CompactDisc, KnownSystem.IBMPCCompatible)]
-        [InlineData(DiscImageCreator.Command.Data, KnownSystem.IBMPCCompatible)]
-        [InlineData(DiscImageCreator.Command.DigitalVideoDisc, KnownSystem.IBMPCCompatible)]
-        [InlineData(DiscImageCreator.Command.Eject, null)]
-        [InlineData(DiscImageCreator.Command.Floppy, KnownSystem.IBMPCCompatible)]
-        [InlineData(DiscImageCreator.Command.GDROM, KnownSystem.SegaDreamcast)]
-        [InlineData(DiscImageCreator.Command.MDS, null)]
-        [InlineData(DiscImageCreator.Command.Reset, null)]
-        [InlineData(DiscImageCreator.Command.SACD, KnownSystem.SuperAudioCD)]
-        [InlineData(DiscImageCreator.Command.Start, null)]
-        [InlineData(DiscImageCreator.Command.Stop, null)]
-        [InlineData(DiscImageCreator.Command.Sub, null)]
-        [InlineData(DiscImageCreator.Command.Swap, KnownSystem.SegaDreamcast)]
-        [InlineData(DiscImageCreator.Command.XBOX, KnownSystem.MicrosoftXBOX)]
-        public void BaseCommandToKnownSystemTest(DiscImageCreator.Command command, KnownSystem? expected)
+        [InlineData(DiscImageCreator.CommandStrings.Audio, KnownSystem.AudioCD)]
+        [InlineData(DiscImageCreator.CommandStrings.BluRay, KnownSystem.SonyPlayStation3)]
+        [InlineData(DiscImageCreator.CommandStrings.Close, null)]
+        [InlineData(DiscImageCreator.CommandStrings.CompactDisc, KnownSystem.IBMPCCompatible)]
+        [InlineData(DiscImageCreator.CommandStrings.Data, KnownSystem.IBMPCCompatible)]
+        [InlineData(DiscImageCreator.CommandStrings.DigitalVideoDisc, KnownSystem.IBMPCCompatible)]
+        [InlineData(DiscImageCreator.CommandStrings.Eject, null)]
+        [InlineData(DiscImageCreator.CommandStrings.Floppy, KnownSystem.IBMPCCompatible)]
+        [InlineData(DiscImageCreator.CommandStrings.GDROM, KnownSystem.SegaDreamcast)]
+        [InlineData(DiscImageCreator.CommandStrings.MDS, null)]
+        [InlineData(DiscImageCreator.CommandStrings.Reset, null)]
+        [InlineData(DiscImageCreator.CommandStrings.SACD, KnownSystem.SuperAudioCD)]
+        [InlineData(DiscImageCreator.CommandStrings.Start, null)]
+        [InlineData(DiscImageCreator.CommandStrings.Stop, null)]
+        [InlineData(DiscImageCreator.CommandStrings.Sub, null)]
+        [InlineData(DiscImageCreator.CommandStrings.Swap, KnownSystem.SegaDreamcast)]
+        [InlineData(DiscImageCreator.CommandStrings.XBOX, KnownSystem.MicrosoftXBOX)]
+        public void BaseCommandToKnownSystemTest(string command, KnownSystem? expected)
         {
             KnownSystem? actual = DiscImageCreator.Converters.ToKnownSystem(command);
             Assert.Equal(expected, actual);

MPF.Test/Utilities/ParametersTest.cs

@@ -10,13 +10,13 @@ namespace MPF.Test.Utilities
     public class ParametersTest
     {
         [Theory]
-        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.CDROM, Command.CompactDisc)]
-        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.DVD, Command.XBOX)]
-        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.LaserDisc, Command.NONE)]
-        [InlineData(KnownSystem.SegaNu, MediaType.BluRay, Command.BluRay)]
-        [InlineData(KnownSystem.AppleMacintosh, MediaType.FloppyDisk, Command.Floppy)]
-        [InlineData(KnownSystem.RawThrillsVarious, MediaType.GDROM, Command.NONE)]
-        public void ParametersFromSystemAndTypeTest(KnownSystem? knownSystem, MediaType? mediaType, Command expected)
+        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.CDROM, CommandStrings.CompactDisc)]
+        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.DVD, CommandStrings.XBOX)]
+        [InlineData(KnownSystem.MicrosoftXBOX, MediaType.LaserDisc, null)]
+        [InlineData(KnownSystem.SegaNu, MediaType.BluRay, CommandStrings.BluRay)]
+        [InlineData(KnownSystem.AppleMacintosh, MediaType.FloppyDisk, CommandStrings.Floppy)]
+        [InlineData(KnownSystem.RawThrillsVarious, MediaType.GDROM, null)]
+        public void ParametersFromSystemAndTypeTest(KnownSystem? knownSystem, MediaType? mediaType, string expected)
         {
             var options = new Options { };
             var actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, options);
@@ -25,26 +25,26 @@ namespace MPF.Test.Utilities
 
         [Theory]
         [InlineData(KnownSystem.AppleMacintosh, MediaType.LaserDisc, true, 20, null, null)]
-        [InlineData(KnownSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc, false, 20, null, new Flag[] { Flag.Raw })]
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, false, 20, null, new Flag[] { Flag.CopyrightManagementInformation, Flag.ScanFileProtect })]
+        [InlineData(KnownSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc, false, 20, null, new string[] { FlagStrings.Raw })]
+        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, false, 20, null, new string[] { FlagStrings.CopyrightManagementInformation, FlagStrings.ScanFileProtect })]
         /* paranoid mode tests */
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.CDROM, true, 1000, 2, new Flag[] { Flag.C2Opcode, Flag.NoFixSubQSecuROM, Flag.ScanFileProtect, Flag.ScanSectorProtect, Flag.SubchannelReadLevel })]
-        [InlineData(KnownSystem.AppleMacintosh, MediaType.CDROM, false, 20, null, new Flag[] { Flag.C2Opcode, Flag.NoFixSubQSecuROM, Flag.ScanFileProtect, Flag.ScanSectorProtect, Flag.SubchannelReadLevel })]
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, true, 500, null, new Flag[] { Flag.CopyrightManagementInformation, Flag.ScanFileProtect })]
-        [InlineData(KnownSystem.HDDVDVideo, MediaType.HDDVD, true, 500, null, new Flag[] { Flag.CopyrightManagementInformation })]
-        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, false, 500, null, new Flag[] { Flag.CopyrightManagementInformation, Flag.ScanFileProtect })]
-        [InlineData(KnownSystem.HDDVDVideo, MediaType.HDDVD, false, 500, null, new Flag[] { Flag.CopyrightManagementInformation })]
+        [InlineData(KnownSystem.IBMPCCompatible, MediaType.CDROM, true, 1000, 2, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect, FlagStrings.ScanSectorProtect, FlagStrings.SubchannelReadLevel })]
+        [InlineData(KnownSystem.AppleMacintosh, MediaType.CDROM, false, 20, null, new string[] { FlagStrings.C2Opcode, FlagStrings.NoFixSubQSecuROM, FlagStrings.ScanFileProtect, FlagStrings.ScanSectorProtect, FlagStrings.SubchannelReadLevel })]
+        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, true, 500, null, new string[] { FlagStrings.CopyrightManagementInformation, FlagStrings.ScanFileProtect })]
+        [InlineData(KnownSystem.HDDVDVideo, MediaType.HDDVD, true, 500, null, new string[] { FlagStrings.CopyrightManagementInformation })]
+        [InlineData(KnownSystem.IBMPCCompatible, MediaType.DVD, false, 500, null, new string[] { FlagStrings.CopyrightManagementInformation, FlagStrings.ScanFileProtect })]
+        [InlineData(KnownSystem.HDDVDVideo, MediaType.HDDVD, false, 500, null, new string[] { FlagStrings.CopyrightManagementInformation })]
         /* reread c2 */
-        [InlineData(KnownSystem.SegaDreamcast, MediaType.GDROM, false, 1000, null, new Flag[] { Flag.C2Opcode })]
-        [InlineData(KnownSystem.SegaDreamcast, MediaType.GDROM, false, -1, null, new Flag[] { Flag.C2Opcode })]
+        [InlineData(KnownSystem.SegaDreamcast, MediaType.GDROM, false, 1000, null, new string[] { FlagStrings.C2Opcode })]
+        [InlineData(KnownSystem.SegaDreamcast, MediaType.GDROM, false, -1, null, new string[] { FlagStrings.C2Opcode })]
 
-        public void ParametersFromOptionsTest(KnownSystem? knownSystem, MediaType? mediaType, bool paranoid, int rereadC2, int? subchannelLevel, Flag[] expected)
+        public void ParametersFromOptionsTest(KnownSystem? knownSystem, MediaType? mediaType, bool paranoid, int rereadC2, int? subchannelLevel, string[] expected)
         {
             var options = new Options { DICParanoidMode = paranoid, DICRereadCount = rereadC2 };
             var actual = new Parameters(knownSystem, mediaType, 'D', "disc.bin", 16, options);
 
-            HashSet<Flag> expectedSet = new HashSet<Flag>(expected ?? new Flag[0]);
-            HashSet<Flag> actualSet = new HashSet<Flag>(actual.Keys.Cast<Flag>() ?? new Flag[0]);
+            HashSet<string> expectedSet = new HashSet<string>(expected ?? new string[0]);
+            HashSet<string> actualSet = new HashSet<string>(actual.Keys.Cast<string>() ?? new string[0]);
             Assert.Equal(expectedSet, actualSet);
             if (rereadC2 == -1 || !Validators.GetValidMediaTypes(knownSystem).Contains(mediaType))
                 Assert.Null(actual.C2OpcodeValue[0]);

MPF/Windows/MainWindow.xaml.cs

@@ -598,7 +598,7 @@ namespace MPF.Windows
                 // If SmartE is detected on the current disc, remove `/sf` from the flags for DIC only
                 if (Env.Options.InternalProgram == InternalProgram.DiscImageCreator && output.Contains("SmartE"))
                 {
-                    ((DiscImageCreator.Parameters)Env.Parameters)[DiscImageCreator.Flag.ScanFileProtect] = false;
+                    ((DiscImageCreator.Parameters)Env.Parameters)[DiscImageCreator.FlagStrings.ScanFileProtect] = false;
                     LogOutput.VerboseLogLn($"SmartE detected, removing {DiscImageCreator.FlagStrings.ScanFileProtect} from parameters");
                 }