fix: cpp_generator._build_type_info -> generator_utils.qualified_for_modules

Author: wdconinc

python/podio_gen/cpp_generator.py

@@ -622,22 +622,6 @@ def _write_all_collections_header(self):
             ),
         )
 
-    @staticmethod
-    def _build_type_info(full_name):
-        """Extract namespace and bare type from a full type name.
-        
-        Args:
-            full_name: Fully qualified type name (e.g., 'nsp::EnergyInNamespace' or 'ExampleHit')
-            
-        Returns:
-            Dictionary with 'full', 'ns', and 'bare' keys
-        """
-        if "::" in full_name:
-            ns, bare = full_name.rsplit("::", 1)
-        else:
-            ns, bare = "", full_name
-        return {"full": full_name, "ns": ns, "bare": bare}
-
     def _write_datamodel_module(self):
         """Write a C++20 module interface file that exports all datamodel types"""
         if not self.enable_modules:
@@ -647,10 +631,10 @@ def _write_datamodel_module(self):
             print(f"Generating C++20 module interface for {self.package_name}")
 
         # Prepare structured type information with namespace details
-        datatypes = [self._build_type_info(name) for name in self.datamodel.datatypes.keys()]
-        components = [self._build_type_info(name) for name in self.datamodel.components.keys()]
-        interfaces = [self._build_type_info(name) for name in self.datamodel.interfaces.keys()]
-        links = [self._build_type_info(name) for name in self.datamodel.links.keys()]
+        datatypes = [DataType(name) for name in self.datamodel.datatypes.keys()]
+        components = [DataType(name) for name in self.datamodel.components.keys()]
+        interfaces = [DataType(name) for name in self.datamodel.interfaces.keys()]
+        links = [DataType(name) for name in self.datamodel.links.keys()]
 
         context = {
             "package_name": self.package_name,

python/podio_gen/generator_utils.py

@@ -147,6 +147,28 @@ def __str__(self):
     def __repr__(self):
         return f"DataType: {self.__str__()}"
 
+    def qualified_for_modules(self, prefix="", suffix=""):
+        """Return the qualified name for C++ using declarations in modules.
+        
+        Args:
+            prefix: Optional prefix to add before the type name (e.g., "Mutable")
+            suffix: Optional suffix to add after the type name (e.g., "Collection")
+        
+        Returns:
+            For namespaced types: 'namespace::PrefixTypeSuffix' (no leading ::)
+            For global types: '::PrefixTypeSuffix' (with leading ::)
+        
+        Examples:
+            DataType("ExampleHit").qualified_for_modules()  # Returns "::ExampleHit"
+            DataType("ExampleHit").qualified_for_modules(prefix="Mutable")  # Returns "::MutableExampleHit"
+            DataType("ex42::Type").qualified_for_modules(suffix="Collection")  # Returns "ex42::TypeCollection"
+        """
+        type_name = f"{prefix}{self.bare_type}{suffix}"
+        if self.namespace:
+            return f"{self.namespace}::{type_name}"
+        else:
+            return f"::{type_name}"
+
     def _to_json(self):
         """Return a string representation that can be parsed again"""
         return self.full_type

python/templates/datamodel_module.ixx.jinja2

@@ -33,27 +33,24 @@ module;
 
 // Include all component headers
 {% for comp in components %}
-#include "{{ incfolder }}{{ comp.bare }}.h"
+#include "{{ incfolder }}{{ comp.bare_type }}.h"
 {% endfor %}
 
 // Include all datatype headers (Object, MutableObject, Collection, etc.)
 {% for dt in datatypes %}
-#include "{{ incfolder }}{{ dt.bare }}.h"
-#include "{{ incfolder }}Mutable{{ dt.bare }}.h"
-#include "{{ incfolder }}{{ dt.bare }}Obj.h"
-#include "{{ incfolder }}{{ dt.bare }}Data.h"
-#include "{{ incfolder }}{{ dt.bare }}Collection.h"
-#include "{{ incfolder }}{{ dt.bare }}CollectionData.h"
+#include "{{ incfolder }}{{ dt.bare_type }}.h"
+#include "{{ incfolder }}Mutable{{ dt.bare_type }}.h"
+#include "{{ incfolder }}{{ dt.bare_type }}Collection.h"
 {% endfor %}
 
 // Include all interface headers
 {% for iface in interfaces %}
-#include "{{ incfolder }}{{ iface.bare }}.h"
+#include "{{ incfolder }}{{ iface.bare_type }}.h"
 {% endfor %}
 
 // Include all link headers
 {% for link in links %}
-#include "{{ incfolder }}{{ link.bare }}Collection.h"
+#include "{{ incfolder }}{{ link.bare_type }}Collection.h"
 {% endfor %}
 
 export module {{ package_name }}.datamodel;
@@ -70,48 +67,30 @@ export namespace podio {
 {% if components %}
 export namespace {{ package_name }} {
 {% for comp in components %}
-{% if comp.ns %}
-  using {{ comp.ns }}::{{ comp.bare }};
-{% else %}
-  using ::{{ comp.bare }};
-{% endif %}
+  using {{ comp.qualified_for_modules() }};
 {% endfor %}
 }
 {% endif %}
 
 // Export all datatypes (Object, MutableObject, Collection)
 {% for dt in datatypes %}
 export namespace {{ package_name }} {
-  // {{ dt.full }} datatype
-{% if dt.ns %}
-  using {{ dt.ns }}::{{ dt.bare }};
-  using {{ dt.ns }}::Mutable{{ dt.bare }};
-  using {{ dt.ns }}::{{ dt.bare }}Collection;
-  using {{ dt.ns }}::{{ dt.bare }}CollectionIterator;
-  using {{ dt.ns }}::{{ dt.bare }}MutableCollectionIterator;  // Note: pattern is {Type}MutableCollectionIterator
-  // Note: {{ dt.bare }}Obj, {{ dt.bare }}Data, and {{ dt.bare }}CollectionData are internal implementation
-  // details and are not exported. They are only accessible through the public handle and collection APIs.
-{% else %}
-  using ::{{ dt.bare }};
-  using ::Mutable{{ dt.bare }};
-  using ::{{ dt.bare }}Collection;
-  using ::{{ dt.bare }}CollectionIterator;
-  using ::{{ dt.bare }}MutableCollectionIterator;  // Note: pattern is {Type}MutableCollectionIterator
-  // Note: {{ dt.bare }}Obj, {{ dt.bare }}Data, and {{ dt.bare }}CollectionData are internal implementation
+  // {{ dt.full_type }} datatype
+  using {{ dt.qualified_for_modules() }};
+  using {{ dt.qualified_for_modules(prefix="Mutable") }};
+  using {{ dt.qualified_for_modules(suffix="Collection") }};
+  using {{ dt.qualified_for_modules(suffix="CollectionIterator") }};
+  using {{ dt.qualified_for_modules(suffix="MutableCollectionIterator") }};  // Note: pattern is {Type}MutableCollectionIterator
+  // Note: {{ dt.bare_type }}Obj, {{ dt.bare_type }}Data, and {{ dt.bare_type }}CollectionData are internal implementation
   // details and are not exported. They are only accessible through the public handle and collection APIs.
-{% endif %}
 }
 {% endfor %}
 
 // Export all interfaces
 {% if interfaces %}
 export namespace {{ package_name }} {
 {% for iface in interfaces %}
-{% if iface.ns %}
-  using {{ iface.ns }}::{{ iface.bare }};
-{% else %}
-  using ::{{ iface.bare }};
-{% endif %}
+  using {{ iface.qualified_for_modules() }};
 {% endfor %}
 }
 {% endif %}
@@ -120,11 +99,7 @@ export namespace {{ package_name }} {
 {% if links %}
 export namespace {{ package_name }} {
 {% for link in links %}
-{% if link.ns %}
-  using {{ link.ns }}::{{ link.bare }}Collection;
-{% else %}
-  using ::{{ link.bare }}Collection;
-{% endif %}
+  using {{ link.qualified_for_modules(suffix="Collection") }};
 {% endfor %}
 }
 {% endif %}