Command line parser

xml_converter/integration_tests/run_tests.py

@@ -15,17 +15,19 @@
 
 
 def run_xml_converter(
+    allow_duplicates: Optional[bool] = None,
     input_xml: Optional[List[str]] = None,
     output_xml: Optional[List[str]] = None,
     input_proto: Optional[List[str]] = None,
     output_proto: Optional[List[str]] = None,
-    split_output_proto: Optional[str] = None,
-    allow_duplicates: Optional[bool] = None,
+    split_by_map_id: Optional[bool] = None
 ) -> Tuple[str, str, int]:
 
     # Build the command to execute the C++ program with the desired function and arguments
     cmd: List[str] = [xml_converter_binary_path]
 
+    if allow_duplicates:
+        cmd += ["--allow-duplicates"]
     if input_xml:
         cmd += ["--input-taco-path"] + input_xml
     if output_xml:
@@ -34,10 +36,8 @@ def run_xml_converter(
         cmd += ["--input-guildpoint-path"] + input_proto
     if output_proto:
         cmd += ["--output-guildpoint-path"] + output_proto
-    if split_output_proto:
-        cmd += ["--output-split-guildpoint-path"] + [split_output_proto]
-    if allow_duplicates:
-        cmd += ["--allow-duplicates"]
+    if split_by_map_id:
+        cmd += ["--split-by-map-id"]
 
     # Run the C++ program and capture its output
     result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -126,10 +126,7 @@ def rebuild_xml_converter_binary() -> None:
 line_patterns_to_ignore = [
     r"^Loading taco pack .*$",
     r"^Loading guildpoint pack .*$",
-    r"^The taco parse function took [0-9]+ milliseconds to run$",
-    r"^The xml write function took [0-9]+ milliseconds to run$",
-    r"^The protobuf read function took [0-9]+ milliseconds to run$",
-    r"^The protobuf write function took [0-9]+ milliseconds to run$",
+    r"^The .+? function took [0-9]+ milliseconds to run$",
     r"^$"
 ]
 
@@ -186,11 +183,12 @@ def main() -> bool:
             output_proto_paths = [proto_output_dir_path]
 
         rawstdout, rawstderr, returncode = run_xml_converter(
+            allow_duplicates=testcase.allow_duplicates,
             input_xml=testcase.xml_input_paths,
             input_proto=testcase.proto_input_paths,
             output_xml=output_xml_paths,
             output_proto=output_proto_paths,
-            allow_duplicates=testcase.allow_duplicates
+            split_by_map_id=testcase.split_by_map_id
         )
 
         # Sanitize and denoise the lines

xml_converter/integration_tests/src/testcase_loader.py

@@ -22,6 +22,7 @@ class Testcase:
     expected_stderr: List[str]
     expected_returncode: int
     allow_duplicates: bool
+    split_by_map_id: bool
 
 
 ################################################################################
@@ -60,6 +61,7 @@ def load_testcase(path: str) -> Optional[Testcase]:
     xml_input_paths: List[str] = []
     proto_input_paths: List[str] = []
     allow_duplicates: bool = False
+    split_by_map_id: bool = False
     for pack_name, pack_type in data["input_paths"].items():
         if not isinstance(pack_name, str):
             print(f"Invalid pack name, expecting a string but got {pack_name}")
@@ -126,6 +128,13 @@ def load_testcase(path: str) -> Optional[Testcase]:
         else:
             allow_duplicates = data["allow_duplicates"]
 
+    if "split_by_map_id" in data:
+        if not isinstance(data["split_by_map_id"], bool):
+            print(f"Invalid Test, expecting bool value for 'split_by_map_id' in {path}")
+            return None
+        else:
+            split_by_map_id = data["split_by_map_id"]
+
     return Testcase(
         name=os.path.basename(path),
         xml_input_paths=xml_input_paths,
@@ -135,7 +144,8 @@ def load_testcase(path: str) -> Optional[Testcase]:
         expected_stdout=to_lines(data["expected_stdout"]),
         expected_stderr=to_lines(data["expected_stderr"]),
         expected_returncode=data["expected_returncode"],
-        allow_duplicates=allow_duplicates
+        allow_duplicates=allow_duplicates,
+        split_by_map_id=split_by_map_id
     )
 
 

xml_converter/integration_tests/test_cases/xml_split_by_map_id/input/pack/xml_file.xml

@@ -0,0 +1,12 @@
+<OverlayData>
+    <MarkerCategory DisplayName="My Category" Name="mycategory">
+    </MarkerCategory>
+
+    <POIs>
+        <POI Type="mycategory" XPos="100" YPos="200" ZPos="300" MapID="0" />
+        <POI Type="mycategory" XPos="110" YPos="210" ZPos="310" MapID="1" />
+        <POI Type="mycategory" XPos="120" YPos="220" ZPos="320" MapID="5" />
+        <POI Type="mycategory" XPos="130" YPos="230" ZPos="330" MapID="2147483647" />
+        <POI Type="mycategory" XPos="140" YPos="240" ZPos="340" MapID="50" />
+    </POIs>
+</OverlayData>

xml_converter/integration_tests/test_cases/xml_split_by_map_id/output_xml/xml_file.xml

@@ -0,0 +1,11 @@
+<OverlayData>
+	<MarkerCategory DisplayName="My Category" ID="KOjMBsKTXpY=" Name="mycategory"/>
+	<POIs>
+		<POI Type="mycategory" MapID="0" XPos="100.000000" YPos="200.000000" ZPos="300.000000"/>
+		<POI Type="mycategory" MapID="1" XPos="110.000000" YPos="210.000000" ZPos="310.000000"/>
+		<POI Type="mycategory" MapID="5" XPos="120.000000" YPos="220.000000" ZPos="320.000000"/>
+		<POI Type="mycategory" MapID="2147483647" XPos="130.000000" YPos="230.000000" ZPos="330.000000"/>
+		<POI Type="mycategory" MapID="50" XPos="140.000000" YPos="240.000000" ZPos="340.000000"/>
+	</POIs>
+</OverlayData>
+

xml_converter/integration_tests/test_cases/xml_split_by_map_id/testcase.yaml

@@ -0,0 +1,6 @@
+input_paths: 
+    "pack": "xml"
+expected_stdout: |
+expected_stderr: |
+expected_returncode: 0
+split_by_map_id: True

xml_converter/src/argument_parser.cpp

@@ -0,0 +1,92 @@
+#include "argument_parser.hpp"
+
+#include <cstring>
+#include <iostream>
+#include <map>
+
+using namespace std;
+
+// Default constructor for the class
+PathConfig::PathConfig()
+    : type(BehaviorType::NONE),
+      format(MarkerFormat::NONE),
+      path("DEFAULT"),
+      split_by_map_id(false) {
+}
+
+PathConfig::PathConfig(BehaviorType type, MarkerFormat format, std::string path, bool split_by_map_id)
+    : type(type), format(format), path(path), split_by_map_id(split_by_map_id) {
+}
+
+ArgumentConfig::ArgumentConfig(BehaviorType type, MarkerFormat format)
+    : type(type), format(format) {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// parse_arguments
+//
+// Processes all of the command line data into a format the internal functions
+// want to receive.
+////////////////////////////////////////////////////////////////////////////////
+ParsedArguments parse_arguments(int argc, char* argv[]) {
+    vector<PathConfig> path_configs;
+    map<string, ArgumentConfig> arg_map = {
+        {"--input-taco-path", ArgumentConfig(BehaviorType::IMPORT, MarkerFormat::XML)},
+        {"--output-taco-path", ArgumentConfig(BehaviorType::EXPORT, MarkerFormat::XML)},
+        {"--input-guildpoint-path", ArgumentConfig(BehaviorType::IMPORT, MarkerFormat::GUILDPOINT)},
+        {"--output-guildpoint-path", ArgumentConfig(BehaviorType::EXPORT, MarkerFormat::GUILDPOINT)}};
+    ParsedArguments parsed_arguments;
+    BehaviorType type = BehaviorType::NONE;
+    MarkerFormat format = MarkerFormat::NONE;
+    bool split_by_map_id = false;
+    string current_argument;
+    vector<string> current_paths;
+
+    for (int i = 1; i < argc; i++) {
+        auto it = arg_map.find(argv[i]);
+        if (it != arg_map.end()) {
+            if (!current_paths.empty()) {
+                for (const string& path : current_paths) {
+                    path_configs.emplace_back(type, format, path, split_by_map_id);
+                }
+                current_paths.clear();
+            }
+            else if (type != BehaviorType::NONE) {
+                cerr << "Error: Expected a path to a directory after " << current_argument << endl;
+                return {};
+            }
+            current_argument = argv[i];
+            type = it->second.type;
+            format = it->second.format;
+            // All flags must be set to default value
+            split_by_map_id = false;
+        }
+        else if (!strcmp(argv[i], "--allow-duplicates")) {
+            parsed_arguments.allow_duplicates = true;
+        }
+        else if (!strcmp(argv[i], "--split-by-map-id")) {
+            if (type == BehaviorType::IMPORT) {
+                cerr << "Error: --split-by-map-id cannot be used after an input argument" << endl;
+                return {};
+            }
+            split_by_map_id = true;
+        }
+        else {
+            current_paths.push_back(argv[i]);
+        }
+    }
+
+    if (!current_paths.empty()) {
+        for (const auto& path : current_paths) {
+            path_configs.emplace_back(type, format, path, split_by_map_id);
+        }
+    }
+    else if (type != BehaviorType::NONE) {
+        cerr << "Error: Expected a path to a directory after " << current_argument << endl;
+        return {};
+    }
+
+    parsed_arguments.path_configs = path_configs;
+    parsed_arguments.is_valid = true;
+    return parsed_arguments;
+}

xml_converter/src/argument_parser.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+// Defines what behavior is expected i.e. (Read/Import or Write/Export)
+enum class BehaviorType {
+    IMPORT,
+    EXPORT,
+    NONE,
+};
+
+// Defines what format the data is expected to be in
+enum class MarkerFormat {
+    XML,
+    GUILDPOINT,
+    NONE,
+};
+
+class PathConfig {
+ public:
+    BehaviorType type;
+    MarkerFormat format;
+    std::string path;
+    bool split_by_map_id = false;
+
+    PathConfig();
+
+    PathConfig(BehaviorType type, MarkerFormat format, std::string path, bool split_by_map_id = false);
+};
+
+class ArgumentConfig {
+ public:
+    BehaviorType type;
+    MarkerFormat format;
+
+    ArgumentConfig(BehaviorType type, MarkerFormat format);
+};
+
+class ParsedArguments {
+ public:
+    std::vector<PathConfig> path_configs;
+    bool allow_duplicates = false;
+    bool is_valid = false;
+};
+
+ParsedArguments parse_arguments(int argc, char* argv[]);