New parsing of Enum-type options

Author: caetera

MainClass.cs

@@ -581,54 +581,12 @@ private static void RegularParametersParsing(string[] args)
 
                 if (outputFormatString != null)
                 {
-                    int outPutFormatInt;
-                    try
-                    {
-                        outPutFormatInt = int.Parse(outputFormatString);
-                    }
-                    catch (FormatException)
-                    {
-                        throw new OptionException(
-                            "unknown output format value (0 for MGF, 1 for mzML, 2 for indexed mzML, 3 for Parquet)",
-                            "-f, --format");
-                    }
-
-                    if (Enum.IsDefined(typeof(OutputFormat), outPutFormatInt) &&
-                        ((OutputFormat) outPutFormatInt) != OutputFormat.NONE)
-                    {
-                        parseInput.OutputFormat = (OutputFormat) outPutFormatInt;
-                    }
-                    else
-                    {
-                        throw new OptionException(
-                            "unknown output format value (0 for MGF, 1 for mzML, 2 for indexed mzML, 3 for Parquet)",
-                            "-f, --format");
-                    }
+                    parseInput.OutputFormat = (OutputFormat)ParseToEnum(typeof(OutputFormat), outputFormatString, "-f, --format");
                 }
 
                 if (metadataFormatString != null)
                 {
-                    int metadataInt;
-                    try
-                    {
-                        metadataInt = int.Parse(metadataFormatString);
-                    }
-                    catch (FormatException)
-                    {
-                        throw new OptionException("unknown metadata format value (0 for JSON, 1 for TXT)",
-                            "-m, --metadata");
-                    }
-
-                    if (Enum.IsDefined(typeof(MetadataFormat), metadataInt) &&
-                        ((MetadataFormat) metadataInt) != MetadataFormat.NONE)
-                    {
-                        parseInput.MetadataFormat = (MetadataFormat) metadataInt;
-                    }
-                    else
-                    {
-                        throw new OptionException("unknown metadata format value (0 for JSON, 1 for TXT)",
-                            "-m, --metadata");
-                    }
+                    parseInput.MetadataFormat = (MetadataFormat)ParseToEnum(typeof(MetadataFormat), metadataFormatString, "-m, --metadata");
                 }
 
                 if (parseInput.MetadataOutputFile != null && Directory.Exists(parseInput.MetadataOutputFile))
@@ -653,29 +611,7 @@ private static void RegularParametersParsing(string[] args)
 
                 if (logFormatString != null)
                 {
-                    int logFormatInt;
-                    try
-                    {
-                        logFormatInt = int.Parse(logFormatString);
-                    }
-                    catch (FormatException)
-                    {
-                        throw new OptionException("unknown log format value (0 for silent, 1 for verbose)",
-                            "-l, --logging");
-                    }
-
-                    if (Enum.IsDefined(typeof(LogFormat), logFormatInt))
-                    {
-                        if ((LogFormat) logFormatInt != LogFormat.NONE)
-                        {
-                            parseInput.LogFormat = (LogFormat) logFormatInt;
-                        }
-                    }
-                    else
-                    {
-                        throw new OptionException("unknown log format value (0 for silent, 1 for verbose)",
-                            "-l, --logging");
-                    }
+                    parseInput.LogFormat = (LogFormat)ParseToEnum(typeof(LogFormat), logFormatString, "-l, --logging");
                 }
 
                 if (parseInput.StdOut)
@@ -789,6 +725,49 @@ private static void ShowHelp(string message, OptionException optionException, Op
             Environment.Exit(-1);
         }
 
+        private static string GetValidEnumLevels(Type enumType)
+        {
+            List<string> output = new List<string>();
+            foreach (int v in Enum.GetValues(enumType))
+            {
+                output.Add(String.Format("{0} ({1})", Enum.GetName(enumType, v), v));
+            }
+
+            return String.Join("\n", output);
+        }
+
+        private static int ParseToEnum(Type enumType, string formatString, string keyName)
+        {
+            if (int.TryParse(formatString, out var formatInt)) //can be parsed as int
+            {
+                if (Enum.IsDefined(enumType, formatInt))
+                {
+                    return formatInt;
+                }
+                else
+                {
+                    throw new OptionException(
+                    String.Format("unknown format value, the following values recognized (case insensitive)\n{0}", GetValidEnumLevels(enumType)),
+                    keyName);
+                }
+
+            }
+            else //try parse as a string
+            {
+                try
+                {
+                    return (int)Enum.Parse(enumType, formatString, true);
+                }
+
+                catch (Exception)
+                {
+                    throw new OptionException(
+                    String.Format("unknown format value, the following values recognized (case insensitive)\n{0}", GetValidEnumLevels(enumType)),
+                    keyName);
+                }
+            }
+        }
+
         private static HashSet<int> ParseMsLevel(string inputString)
         {
             HashSet<int> result = new HashSet<int>();