Adds a CLI Argument parser

lib/argparse/CLIHelper.dart

@@ -0,0 +1,108 @@
+import 'package:libac_dart/argparse/types/Bool.dart';
+import 'package:libac_dart/argparse/types/Integers.dart';
+import 'package:libac_dart/argparse/types/String.dart';
+import 'package:libac_dart/nbt/Stream.dart';
+
+import 'Args.dart';
+
+class CLIHelper {
+  /// Generates usage info
+  ///
+  /// This will create a standard CLI Usage info string that can be directly printed to the console after the program header
+  static String makeArgCLIHelp(Arguments defaults) {
+    StringBuilder builder = StringBuilder();
+    List<String> argNames = defaults.getArgNames();
+
+    for (String name in argNames) {
+      builder.append("--${name}");
+
+      Argument arg = defaults.getArg(name)!;
+      if (arg.hasValue) {
+        builder.append("=<T>");
+      }
+
+      builder.append("\t\t\t${arg.description}\n");
+    }
+
+    return builder.toString();
+  }
+
+  /// Parses and returns the arguments list with keeping defaults in mind
+  static Future<Arguments> parseArgs(
+      List<String> args, Arguments defaults) async {
+    Arguments arguments = defaults.clone();
+    for (int i = 0; i < args.length; i++) {
+      Argument arg = await _parseArgument(args[i]);
+      Argument? defArg;
+      if (defaults.hasArg(arg.name)) defArg = defaults.getArg(arg.name)!;
+
+      if (!arg.hasValue) {
+        if (defArg != null) {
+          arg = defArg;
+        }
+      }
+
+      arguments.setArg(arg);
+    }
+
+    return arguments;
+  }
+
+  static Future<Argument> _parseArgument(String arg) async {
+    if (arg.startsWith("--")) {
+      var parts = arg.split("=");
+      String name = await _getNamePart(parts[0]);
+      if (parts.length == 1)
+        return BoolArgument(name: name);
+      else if (parts.length == 2) {
+        String value = await _getValuePart(parts[1]);
+        ArgumentType typeOfArg = await _getArgumentType(value);
+
+        switch (typeOfArg) {
+          case ArgumentType.INTEGER:
+            {
+              return IntegerArgument(name: name, value: int.parse(value));
+            }
+          case ArgumentType.BOOL:
+            {
+              return BoolArgument(name: name);
+            }
+          case ArgumentType.DOUBLE:
+            {
+              return DoubleArgument(name: name, value: double.parse(value));
+            }
+          case ArgumentType.STRING:
+            {
+              return StringArgument(name: name, value: value);
+            }
+        }
+      } else
+        throw new Exception("Argument is malformed");
+    } else
+      throw new Exception("Not in a valid format");
+  }
+
+  static Future<String> _getNamePart(String value) async {
+    return value.substring(2);
+  }
+
+  static Future<String> _getValuePart(String entry) async {
+    return entry;
+  }
+
+  static Future<ArgumentType> _getArgumentType(String input) async {
+    try {
+      int.parse(input);
+      return ArgumentType.INTEGER;
+    } catch (E) {}
+    try {
+      double.parse(input);
+      return ArgumentType.DOUBLE;
+    } catch (E) {}
+
+    if (input.isEmpty)
+      return ArgumentType.BOOL;
+    else
+      return ArgumentType.STRING;
+  }
+}