Using the .proto type values in generated code

The types of each field are now dynamically determined via reading the proto file and not assumed based on the markdown docs frontmatter data.

xml_converter/doc/trigger/guid.md

@@ -5,7 +5,6 @@ class: UniqueId
 xml_fields: ["GUID"]
 applies_to: ["Icon", "Trail"]
 protobuf_field: guid
-protobuf_type: String
 ---
 A globally unique identifier value to make sure this maker's trigger reset data is always assocaited with this marker and never lost or confused with other markers.
 

xml_converter/generators/cpp_templates/attribute_template.hpp

@@ -16,9 +16,7 @@
     };
 {% else: %}
     class XMLError;
-    namespace waypoint {
-    class {{class_name}};
-    }
+    {{proto_field_cpp_type_prototype}}
 
     class {{class_name}} {
      public:
@@ -38,8 +36,8 @@ void xml_attribute_to_{{attribute_name}}(
     bool* is_set);
 std::string {{attribute_name}}_to_xml_attribute(const std::string& attribute_name, const {{class_name}}* value);
 {% if type == "Enum":%}
-    waypoint::{{class_name}} to_proto_{{attribute_name}}({{class_name}} attribute_value);
+    {{proto_field_cpp_type}} to_proto_{{attribute_name}}({{class_name}} attribute_value);
 {% else: %}
-    waypoint::{{class_name}}* to_proto_{{attribute_name}}({{class_name}} attribute_value);
+    {{proto_field_cpp_type}}* to_proto_{{attribute_name}}({{class_name}} attribute_value);
 {% endif %}
-{{class_name}} from_proto_{{attribute_name}}(waypoint::{{class_name}} proto_{{attribute_name}});
+{{class_name}} from_proto_{{attribute_name}}({{proto_field_cpp_type}} proto_{{attribute_name}});

xml_converter/generators/cpp_templates/attribute_template_compoundvalue.cpp

@@ -48,15 +48,15 @@ void xml_attribute_to_{{attribute_name}}(
     }
 {% endif %}
 
-waypoint::{{class_name}}* to_proto_{{attribute_name}}({{class_name}} attribute_value) {
-    waypoint::{{class_name}}* proto_{{attribute_name}} = new waypoint::{{class_name}}();
+{{proto_field_cpp_type}}* to_proto_{{attribute_name}}({{class_name}} attribute_value) {
+    {{proto_field_cpp_type}}* proto_{{attribute_name}} = new {{proto_field_cpp_type}}();
     {% for attribute_variable in attribute_variables %}
         proto_{{attribute_name}}->set_{{attribute_variable.protobuf_field}}(attribute_value.{{attribute_variable.attribute_name}});
     {% endfor %}
     return proto_{{attribute_name}};
 }
 
-{{class_name}} from_proto_{{attribute_name}}(waypoint::{{class_name}} proto_{{attribute_name}}) {
+{{class_name}} from_proto_{{attribute_name}}({{proto_field_cpp_type}} proto_{{attribute_name}}) {
     {{class_name}} {{attribute_name}};
     {% for attribute_variable in attribute_variables: %}
         {{attribute_name}}.{{attribute_variable.attribute_name}} = proto_{{attribute_name}}.{{attribute_variable.protobuf_field}}();

xml_converter/generators/cpp_templates/attribute_template_enum.cpp

@@ -57,21 +57,21 @@ string {{attribute_name}}_to_xml_attribute(const std::string& attribute_name, co
     }
 }
 
-waypoint::{{class_name}} to_proto_{{attribute_name}}({{class_name}} attribute_value) {
+{{proto_field_cpp_type}} to_proto_{{attribute_name}}({{class_name}} attribute_value) {
     switch (attribute_value) {
         {% for attribute_variable in attribute_variables %}
             case {{class_name}}::{{attribute_variable.attribute_name}}:
-                return waypoint::{{class_name}}::{{attribute_variable.attribute_name}};
+                return {{proto_field_cpp_type}}::{{attribute_variable.attribute_name}};
         {% endfor %}
         default:
-            return waypoint::{{class_name}}::{{attribute_variables[0].attribute_name}};
+            return {{proto_field_cpp_type}}::{{attribute_variables[0].attribute_name}};
     }
 }
 
-{{class_name}} from_proto_{{attribute_name}}(waypoint::{{class_name}} proto_{{attribute_name}}) {
+{{class_name}} from_proto_{{attribute_name}}({{proto_field_cpp_type}} proto_{{attribute_name}}) {
     switch (proto_{{attribute_name}}) {
         {% for attribute_variable in attribute_variables %}
-            case waypoint::{{class_name}}::{{attribute_variable.attribute_name}}:
+            case {{proto_field_cpp_type}}::{{attribute_variable.attribute_name}}:
                 return {{class_name}}::{{attribute_variable.attribute_name}};
         {% endfor %}
         default:

xml_converter/generators/cpp_templates/attribute_template_multiflagvalue.cpp

@@ -59,15 +59,15 @@ string {{attribute_name}}_to_xml_attribute(const std::string& attribute_name, co
     return " " + attribute_name + "=\"" + output + "\"";
 }
 
-waypoint::{{class_name}}* to_proto_{{attribute_name}}({{class_name}} attribute_value) {
-    waypoint::{{class_name}}* proto_{{attribute_name}} = new waypoint::{{class_name}}();
+{{proto_field_cpp_type}}* to_proto_{{attribute_name}}({{class_name}} attribute_value) {
+    {{proto_field_cpp_type}}* proto_{{attribute_name}} = new {{proto_field_cpp_type}}();
     {% for n, attribute_variable in enumerate(attribute_variables)%}
         proto_{{attribute_name}}->set_{{attribute_variable.attribute_name}}(attribute_value.{{attribute_variable.attribute_name}});
     {% endfor %}
     return proto_{{attribute_name}};
 }
 
-{{class_name}} from_proto_{{attribute_name}}(waypoint::{{class_name}} proto_{{attribute_name}}) {
+{{class_name}} from_proto_{{attribute_name}}({{proto_field_cpp_type}} proto_{{attribute_name}}) {
     {{class_name}} {{attribute_name}};
     {% for n, attribute_variable in enumerate(attribute_variables)%}
         {{attribute_name}}.{{attribute_variable.attribute_name}} = proto_{{attribute_name}}.{{attribute_variable.attribute_name}}();

xml_converter/generators/cpp_templates/class_template.cpp

@@ -98,7 +98,7 @@ waypoint::{{cpp_class}} {{cpp_class}}::as_protobuf() const {
     {% for attribute_variable in attribute_variables %}
         {% if attribute_variable.is_component == false %}
             if (this->{{attribute_variable.attribute_flag_name}}) {
-                {% if attribute_variable.protobuf_type in ["MultiflagValue", "CompoundValue", "Custom", "CompoundCustomClass"] %}
+                {% if not attribute_variable.is_proto_field_scalar %}
                     proto_{{cpp_class_header}}.{{attribute_variable.mutable_proto_drilldown_calls}}set_allocated_{{attribute_variable.protobuf_field}}(to_proto_{{attribute_variable.class_name}}(this->{{attribute_variable.attribute_name}}));
                 {% else %}
                     proto_{{cpp_class_header}}.{{attribute_variable.mutable_proto_drilldown_calls}}set_{{attribute_variable.protobuf_field}}(to_proto_{{attribute_variable.class_name}}(this->{{attribute_variable.attribute_name}}));
@@ -112,12 +112,10 @@ waypoint::{{cpp_class}} {{cpp_class}}::as_protobuf() const {
 void {{cpp_class}}::parse_protobuf(waypoint::{{cpp_class}} proto_{{cpp_class_header}}) {
     {% for attribute_variable in attribute_variables %}
         {% if attribute_variable.is_component == false %}
-            {% if attribute_variable.protobuf_type in ["MultiflagValue", "CompoundValue", "Custom", "CompoundCustomClass"] %}
+            {% if not attribute_variable.is_proto_field_scalar %}
                 if (proto_{{cpp_class_header}}{{attribute_variable.proto_drilldown_calls}}.has_{{attribute_variable.protobuf_field}}()) {
-            {% elif attribute_variable.protobuf_type == "String" %}
+            {% elif attribute_variable.protobuf_cpp_type == "std::string" %}
                 if (proto_{{cpp_class_header}}{{attribute_variable.proto_drilldown_calls}}.{{attribute_variable.protobuf_field}}() != "") {
-            {% elif attribute_variable.protobuf_type ==  "Enum" %}
-                if (proto_{{cpp_class_header}}{{attribute_variable.proto_drilldown_calls}}.{{attribute_variable.protobuf_field}}() != 0) {
             {% else %}
                 if (proto_{{cpp_class_header}}{{attribute_variable.proto_drilldown_calls}}.{{attribute_variable.protobuf_field}}() != 0) {
             {% endif %}

xml_converter/generators/generate_cpp.py

@@ -4,6 +4,7 @@
 from jinja_helpers import UnindentBlocks
 from util import lowercase, capitalize, normalize, Document, SchemaType
 import os
+from protobuf_types import is_proto_field_scalar, get_proto_field_cpp_type, get_proto_field_cpp_prototype
 
 
 XML_ATTRIBUTE_PARSER_DEFAULT_ARGUMENTS: Final[List[str]] = ["attribute", "errors"]
@@ -53,7 +54,16 @@ class AttributeVariable:
     cpp_type: str
     class_name: str
     xml_fields: List[str]
+
+    # The name of the field in the protobuf that this attribute corresponds to.
     protobuf_field: str
+
+    # A the cpp type the protobuf library expects to receive.
+    protobuf_cpp_type: str
+
+    # Protoc cares if a field is scalar or not in the case of "set" vs "set allocated".
+    is_proto_field_scalar: bool
+
     args: List[str] = field(default_factory=list)
     default_xml_field: str = ""
     side_effects: List[str] = field(default_factory=list)
@@ -72,13 +82,6 @@ class AttributeVariable:
     uses_file_path: bool = False
     is_component: bool = False
 
-    # A flag to override the type that should be used when writing or reading from a protobuf
-    protobuf_type: str = ""
-
-    def __post_init__(self) -> None:
-        if self.protobuf_type == "":
-            self.protobuf_type = self.attribute_type
-
 
 ################################################################################
 # CPPInclude
@@ -284,6 +287,8 @@ def generate_cpp_variable_data(
                         xml_fields=component_xml_fields,
                         default_xml_field=component_default_xml_field,
                         protobuf_field=component["protobuf_field"],
+                        protobuf_cpp_type=get_proto_field_cpp_type(doc_type, fieldval["protobuf_field"] + "." + component["protobuf_field"]),
+                        is_proto_field_scalar=is_proto_field_scalar(doc_type, fieldval["protobuf_field"] + "." + component["protobuf_field"]),
                         attribute_flag_name=attribute_name + "_is_set",
                         write_to_xml=write_to_xml,
                         is_component=True,
@@ -294,10 +299,6 @@ def generate_cpp_variable_data(
                 if fieldval['xml_bundled_components'] == []:
                     write_to_xml = False
 
-            protobuf_type = ""
-            if "protobuf_type" in fieldval:
-                protobuf_type = fieldval["protobuf_type"]
-
             attribute_variable = AttributeVariable(
                 attribute_name=attribute_name,
                 attribute_type=fieldval["type"],
@@ -306,13 +307,14 @@ def generate_cpp_variable_data(
                 xml_fields=xml_fields,
                 default_xml_field=default_xml_field,
                 protobuf_field=protobuf_field,
+                protobuf_cpp_type=get_proto_field_cpp_type(doc_type, fieldval["protobuf_field"]),
+                is_proto_field_scalar=is_proto_field_scalar(doc_type, fieldval["protobuf_field"]),
                 proto_drilldown_calls=proto_drilldown_calls,
                 mutable_proto_drilldown_calls=mutable_proto_drilldown_calls,
                 args=args,
                 write_to_xml=write_to_xml,
                 attribute_flag_name=attribute_name + "_is_set",
                 side_effects=side_effects,
-                protobuf_type=protobuf_type
             )
             attribute_variables.append(attribute_variable)
 
@@ -357,6 +359,19 @@ def write_attribute(output_directory: str, data: Dict[str, Document]) -> None:
         metadata[filepath] = data[filepath].metadata
         attribute_name = attribute_name_from_markdown_data(metadata[filepath]['name'])
 
+        proto_field_type: str = ""
+        proto_field_prototype: Optional[str] = None
+        for marker_type in metadata[filepath]["applies_to"]:
+            new_type = get_proto_field_cpp_type(marker_type, metadata[filepath]["protobuf_field"])
+            if proto_field_type != "" and proto_field_type != new_type:
+                print("Proto Field type differes between different marker types for ", metadata[filepath]["protobuf_field"])
+            proto_field_type = new_type
+
+            new_prototype = get_proto_field_cpp_prototype(marker_type, metadata[filepath]["protobuf_field"])
+            if proto_field_prototype != None and proto_field_prototype != new_prototype:
+                print("Proto Field prototype differes between different marker types for ", metadata[filepath]["protobuf_field"])
+            proto_field_prototype = new_prototype
+
         proto_drilldown_calls: str
         mutable_proto_drilldown_calls: str
         protobuf_field: str
@@ -368,6 +383,7 @@ def write_attribute(output_directory: str, data: Dict[str, Document]) -> None:
                 for item in metadata[filepath]['flags'][flag]:
                     xml_fields.append(normalize(item))
 
+                # TODO: Replace AttributeVariable with a more fitting dataclass
                 attribute_variable = AttributeVariable(
                     attribute_name=flag,
                     attribute_type=metadata[filepath]['type'],
@@ -376,7 +392,9 @@ def write_attribute(output_directory: str, data: Dict[str, Document]) -> None:
                     xml_fields=xml_fields,
                     protobuf_field=protobuf_field,
                     proto_drilldown_calls=proto_drilldown_calls,
-                    mutable_proto_drilldown_calls=mutable_proto_drilldown_calls
+                    mutable_proto_drilldown_calls=mutable_proto_drilldown_calls,
+                    protobuf_cpp_type="",
+                    is_proto_field_scalar=False
                 )
                 attribute_variables.append(attribute_variable)
 
@@ -392,6 +410,7 @@ def write_attribute(output_directory: str, data: Dict[str, Document]) -> None:
                     xml_fields.append(normalize(item))
                 if component['name'] in metadata[filepath]['xml_bundled_components']:
                     xml_bundled_components.append(component_attribute_name)
+                # TODO: Replace AttributeVariable with a more fitting dataclass
                 attribute_variable = AttributeVariable(
                     attribute_name=component_attribute_name,
                     attribute_type=metadata[filepath]['type'],
@@ -400,7 +419,9 @@ def write_attribute(output_directory: str, data: Dict[str, Document]) -> None:
                     xml_fields=xml_fields,
                     protobuf_field=component["protobuf_field"],
                     proto_drilldown_calls=proto_drilldown_calls,
-                    mutable_proto_drilldown_calls=mutable_proto_drilldown_calls
+                    mutable_proto_drilldown_calls=mutable_proto_drilldown_calls,
+                    protobuf_cpp_type="",
+                    is_proto_field_scalar=False,
                 )
                 attribute_variables.append(attribute_variable)
 
@@ -409,6 +430,7 @@ def write_attribute(output_directory: str, data: Dict[str, Document]) -> None:
                 xml_fields = []
                 for item in metadata[filepath]['values'][value]:
                     xml_fields.append(normalize(item))
+                # TODO: Replace AttributeVariable with a more fitting dataclass
                 attribute_variable = AttributeVariable(
                     attribute_name=value,
                     attribute_type=metadata[filepath]['type'],
@@ -417,7 +439,9 @@ def write_attribute(output_directory: str, data: Dict[str, Document]) -> None:
                     xml_fields=xml_fields,
                     protobuf_field=protobuf_field,
                     proto_drilldown_calls=proto_drilldown_calls,
-                    mutable_proto_drilldown_calls=mutable_proto_drilldown_calls
+                    mutable_proto_drilldown_calls=mutable_proto_drilldown_calls,
+                    protobuf_cpp_type="",
+                    is_proto_field_scalar=False,
                 )
                 attribute_variables.append(attribute_variable)
 
@@ -430,15 +454,20 @@ def write_attribute(output_directory: str, data: Dict[str, Document]) -> None:
                 attribute_variables=sorted(attribute_variables, key=get_attribute_variable_key),
                 class_name=capitalize(attribute_name, delimiter=""),
                 type=metadata[filepath]['type'],
+                proto_field_cpp_type=proto_field_type,
+                proto_field_cpp_type_prototype=proto_field_prototype,
             ))
 
         with open(os.path.join(output_directory, attribute_name + "_gen.cpp"), 'w') as f:
             f.write(template[metadata[filepath]['type']].render(
                 attribute_name=attribute_name,
+                # TODO: Should this attribute_variables list be sorted? The hpp one is.
                 attribute_variables=attribute_variables,
                 class_name=capitalize(attribute_name, delimiter=""),
                 enumerate=enumerate,
-                xml_bundled_components=xml_bundled_components
+                xml_bundled_components=xml_bundled_components,
+                proto_field_cpp_type=proto_field_type,
+                proto_field_cpp_type_prototype=proto_field_prototype,
             ))
 
 

xml_converter/generators/main.py

@@ -69,7 +69,6 @@
         optional={
             "side_effects": array_t(string_t()),
             "uses_file_path": boolean_t(),
-            "protobuf_type": enum_t(["Int32", "Fixed32", "Float32", "String"]),
         }
     ),
 })