Work towards v1.0 data model with encapsulated weak_ptr as basis for instances

src/ifcopenshell-python/ifcopenshell/express/header.py

@@ -26,16 +26,14 @@ import documentation
 
 from collections import defaultdict
 
-USE_VIRTUAL_INHERITANCE = True
-
 class Header(codegen.Base):
     def __init__(self, mapping):
         declarations = []
 
         case_lookup = lambda nm: [k for k in mapping.schema.keys if k.lower() == nm.lower()][0]
-        case_normalize = lambda nm: nm if nm.startswith("IfcUtil::") else case_lookup(nm)
+        case_normalize = lambda nm: nm if nm.startswith("express::") else case_lookup(nm)
         create_supertype_statement = lambda nms: ", ".join(
-            "public %s %s" % ("" if c.startswith("IfcUtil::") else "", c) for c in nms
+            "public %s %s" % ("" if c.startswith("express::") else "", c) for c in nms
         )
 
         write = lambda str, **kwargs: declarations.append(
@@ -43,7 +41,7 @@ class Header(codegen.Base):
             % dict({"documentation": templates.multi_line_comment(documentation.description(kwargs["name"]))}, **kwargs)
         )
 
-        forward_names = list(mapping.schema.entities.keys()) + list(mapping.schema.simpletypes.keys())
+        forward_names = list(mapping.schema.entities.keys()) + list(mapping.schema.simpletypes.keys()) + list(mapping.schema.selects.keys())
         forward_definitions = "".join(["class %s; " % n for n in forward_names])
 
         select_super_types = defaultdict(list)
@@ -51,7 +49,20 @@ class Header(codegen.Base):
         for name, type in mapping.schema.selects.items():
             for nm in type.values:
                 select_super_types[str(nm).lower()].append(name)
-            write(templates.select_virtual if USE_VIRTUAL_INHERITANCE else templates.select_plain, name=name)
+
+            # Previously we used (virtual) inheritance, now we use casts to go from Base to Select.
+            # Casts only go one conversion step deep, so we need to explicitly all descendant selected leafs.
+            def visit_select(s):
+                for x in map(str, s.values):
+                    yield x
+                    if mapping.schema.is_select(x):
+                        yield from visit_select(mapping.schema.selects[x])
+                
+            write(templates.select, 
+                  name=name, 
+                  template_items="\n".join(templates.select_list_item % {'item_name': nm} for nm in visit_select(type)),
+                  cast_functions="\n".join(templates.select_cast_function % {'name': name, 'item_name': nm} for nm in visit_select(type)),
+            )
 
         def get_select_super_types(nm, bases=[]):
             x = list(select_super_types[nm.lower()])
@@ -82,13 +93,15 @@ class Header(codegen.Base):
                         all_superclasses.append(superclass)
                         superclass = mapping.simple_type_parent(superclass)
                 else:
-                    superclasses.append("IfcUtil::IfcBaseType")
+                    superclasses.append("express::DeclaredType")
 
-                if USE_VIRTUAL_INHERITANCE:
-                    superclasses.extend(get_select_super_types(name, bases=all_superclasses))
+                # This is no longer used, previously virtual inheritance was used, now
+                # a variant-like approach is used instead, so the definition of selects
+                # is on the other side again, as it is in Express.
+                # superclasses.extend(get_select_super_types(name, bases=all_superclasses))
 
                 is_emitted = (
-                    lambda nm: nm == "IfcUtil::IfcBaseType"
+                    lambda nm: nm == "express::DeclaredType"
                     or nm in mapping.schema.selects
                     or nm.lower() in emitted_simpletypes
                 )
@@ -99,7 +112,9 @@ class Header(codegen.Base):
 
                 emitted_simpletypes.add(name.lower())
 
-                superclass_statement = create_supertype_statement(superclasses)
+                # with the v1 data model we're back to exactly one supertype, no more virtual inheritance to handle selects
+                assert len(superclasses) == 1
+                superclass_statement = superclasses[0]
 
                 write(
                     templates.simpletype, name=name, type=type_str, attr_type=attr_type, superclass=superclass_statement
@@ -128,7 +143,11 @@ class Header(codegen.Base):
                         type_str = mapping.get_parameter_type(attr)
                         if mapping.make_argument_type(attr) != "IfcUtil::Argument_UNKNOWN":
                             attr_lines.append("%s %s() const;" % (type_str, attr.name))
-                            attr_lines.append("void set%s(%s v);" % (attr.name, type_str))
+                            attr_lines.append("void set%s(const %s& v);" % (attr.name, type_str))
+                            if type_str == 'std::optional< std::string >':
+                                # because a 2-step char[] -> std::string -> optional<string> is not allowed
+                                # attr_lines.append("void set%s(const %s& v);" % (attr.name, 'std::string'))
+                                pass
 
                     [write_method(attr) for attr in type.attributes]
 
@@ -157,11 +176,11 @@ class Header(codegen.Base):
                         all_supertypes.append(tt.supertypes[0])
                         tt = mapping.schema.entities[tt.supertypes[0]]
 
-                    supertypes = list(type.supertypes) if len(type.supertypes) else ["IfcUtil::IfcBaseEntity"]
-                    if USE_VIRTUAL_INHERITANCE:
-                        supertypes.extend(get_select_super_types(name, bases=all_supertypes))
+                    supertypes = list(type.supertypes) if len(type.supertypes) else ["express::Entity"]
+                    # supertypes.extend(get_select_super_types(name, bases=all_supertypes))
                     supertypes = list(map(case_normalize, supertypes))
-                    superclass = create_supertype_statement(supertypes)
+                    assert len(supertypes) == 1
+                    superclass = supertypes[0]
 
                     argument_count = mapping.argument_count(type)