Add partial support for SwcImplementation

src/autosar/xml/element.py

@@ -432,6 +432,101 @@ def __init__(self,
         self._assign_optional("x", x, int)  # .X
 
 
+class EngineeringObject(ARObject):
+    """
+    Group AR:ENGINEERING-OBJECT
+    """
+
+    def __init__(self,
+                 label: str | None = None,
+                 category: str | None = None) -> None:
+        super().__init__()
+        self.label: str | None = None  # .SHORT-LABEL
+        self.category: str | None = None  # .CATEGORY
+        self._assign_optional_strict("label", label, str)
+        self._assign_optional_strict("category", category, str)
+
+
+class AutosarEngineeringObject(EngineeringObject):
+    """
+    Complex type AR:AUTOSAR-ENGINEERING-OBJECT
+    Tag variants: 'AUTOSAR-ENGINEERING-OBJECT' | 'ARTIFACT-DESCRIPTOR'
+
+    Same constructor as parent class
+    """
+
+
+class Code(Identifiable):
+    """
+    Complex type AR:CODE
+    Tag variants: 'CODE'
+    """
+
+    def __init__(self,
+                 name: str,
+                 artifact_descriptors: AutosarEngineeringObject | list[AutosarEngineeringObject] | None = None,
+                 **kwargs) -> None:
+        super().__init__(name, **kwargs)
+        self.artifact_descriptors: list[AutosarEngineeringObject] = []  # .
+        # .CALLBACK-HEADER-REFS not yet supported
+        if artifact_descriptors is not None:
+            if isinstance(artifact_descriptors, AutosarEngineeringObject):
+                self.append_artifact_descriptor(artifact_descriptors)
+            else:
+                for artifact_descriptor in artifact_descriptors:
+                    self.append_artifact_descriptor(artifact_descriptor)
+
+    def append_artifact_descriptor(self, artifact_descriptor: AutosarEngineeringObject) -> None:
+        """
+        Appends artifact_descriptor to internal list of descriptors
+        """
+        if isinstance(artifact_descriptor, AutosarEngineeringObject):
+            self.artifact_descriptors.append(artifact_descriptor)
+        else:
+            raise TypeError("artifact_descriptor must be of type AutosarEngineeringObject")
+
+
+class Implementation(ARElement):
+    """
+    Group AR:IMPLEMENTATION
+    """
+
+    def __init__(self,
+                 name: str,
+                 code_descriptors: Code | list[Code] | None = None,
+                 **kwargs) -> None:
+        super().__init__(name, **kwargs)
+        # .BUILD-ACTION-MANIFEST-REF-CONDITIONAL not yet supported
+        self.code_descriptors: list[Code] = []  # .CODE-DESCRIPTORS
+        # .COMPILERS not yet supported
+        # .GENERATED-ARTIFACTS not yet supported
+        # .HW-ELEMENT-REFS not yet supported
+        # .LINKERS not yet supported
+        # .MC-SUPPORT not yet supported
+        # .PROGRAMMING-LANGUAGE not yet supported
+        # .REQUIRED-ARTIFACTS not yet supported
+        # .REQUIRED-GENERATOR-TOOLS not yet supported
+        # .RESOURCE-CONSUMPTION not yet supported
+        # .SW-VERSION not yet supported
+        # .SWC-BSW-MAPPING-REF not yet supported
+        # .USED-CODE-GENERATOR not yet supported
+        # .VENDOR-ID not yet supported
+        if code_descriptors is not None:
+            if isinstance(code_descriptors, Code):
+                self.append_code_descriptor(code_descriptors)
+            else:
+                for code_descriptor in code_descriptors:
+                    self.append_code_descriptor(code_descriptor)
+
+    def append_code_descriptor(self, code_descriptors: Code) -> None:
+        """
+        Appends code descriptor to internal list of descriptors
+        """
+        if isinstance(code_descriptors, Code):
+            self.code_descriptors.append(code_descriptors)
+        else:
+            raise TypeError("code_descriptors must be of type Code")
+
 # --- Reference elements
 
 
@@ -874,6 +969,20 @@ def _accepted_subtypes(self) -> set[ar_enum.IdentifiableSubTypes]:
         """Acceptable values for dest"""
         return {ar_enum.IdentifiableSubTypes.SW_COMPONENT_PROTOTYPE}
 
+
+class SwcInternalBehaviorRef(BaseRef):
+    """
+    Reference to AR:SWC-INTERNAL-BEHAVIOR--SUBTYPES-ENUM
+    """
+
+    def __init__(self, value: str) -> None:
+        super().__init__(value, ar_enum.IdentifiableSubTypes.SWC_INTERNAL_BEHAVIOR)
+
+    def _accepted_subtypes(self) -> set[ar_enum.IdentifiableSubTypes]:
+        """Acceptable values for dest"""
+        return {ar_enum.IdentifiableSubTypes.SWC_INTERNAL_BEHAVIOR}
+
+
 # --- Documentation Elements
 
 
@@ -5683,3 +5792,23 @@ def __init__(self,
                  name: str,
                  **kwargs) -> None:
         super().__init__(name, **kwargs)
+
+
+class SwcImplementation(Implementation):
+    """
+    Complex type AR:SWC-IMPLEMENTATION
+    Tag variants: 'SWC-IMPLEMENTATION'
+    """
+
+    def __init__(self,
+                 name: str,
+                 behavior_ref: SwcInternalBehaviorRef | None = None,
+                 code_descriptors: Code | list[Code] | None = None,
+                 required_rte_vendor: str | None = None,
+                 **kwargs) -> None:
+        super().__init__(name, code_descriptors, **kwargs)
+        self.behavior_ref: SwcInternalBehaviorRef | None = None
+        # .PER-INSTANCE-MEMORY-SIZES not yet supported
+        self.required_rte_vendor: str | None = None
+        self._assign_optional("behavior_ref", behavior_ref, SwcInternalBehaviorRef)
+        self._assign_optional_strict("required_rte_vendor", required_rte_vendor, str)

src/autosar/xml/enumeration.py

@@ -236,8 +236,9 @@ class IdentifiableSubTypes(Enum):
     SW_ADDR_METHOD = 42
     SW_BASE_TYPE = 43
     SW_COMPONENT_PROTOTYPE = 44
-    UNIT = 45
-    VARIABLE_DATA_PROTOTYPE = 46
+    SWC_INTERNAL_BEHAVIOR = 45
+    UNIT = 46
+    VARIABLE_DATA_PROTOTYPE = 47
 
 
 class IntervalType(Enum):
@@ -734,6 +735,7 @@ class VersionedTextValue:
         "SW-ADDR-METHOD": IdentifiableSubTypes.SW_ADDR_METHOD,
         "SW-BASE-TYPE": IdentifiableSubTypes.SW_BASE_TYPE,
         "SW-COMPONENT-PROTOTYPE": IdentifiableSubTypes.SW_COMPONENT_PROTOTYPE,
+        "SWC-INTERNAL-BEHAVIOR": IdentifiableSubTypes.SWC_INTERNAL_BEHAVIOR,
         "UNIT": IdentifiableSubTypes.UNIT,
         "VARIABLE-DATA-PROTOTYPE": IdentifiableSubTypes.VARIABLE_DATA_PROTOTYPE,
     },
@@ -1088,8 +1090,9 @@ def xml_to_enum(enum_type_name: str, xml_text: str, schema_version: int = ar_bas
         "SW-ADDR-METHOD",                                # 42
         "SW-BASE-TYPE",                                  # 43
         "SW-COMPONENT-PROTOTYPE",                        # 44
-        "UNIT",                                          # 45
-        "VARIABLE-DATA-PROTOTYPE",                       # 46
+        "SWC-INTERNAL-BEHAVIOR",                         # 45
+        "UNIT",                                          # 46
+        "VARIABLE-DATA-PROTOTYPE",                       # 47
     ],
     "IntervalType": [
         "CLOSED",  # 0

src/autosar/xml/reader.py

@@ -114,8 +114,10 @@ def __init__(self,
             # CompuMethod
             'COMPU-METHOD': self._read_compu_method,
 
-            # Common structure elements
+            # Common structure and general template elements
             'DATA-FILTER': self._read_data_filter,
+            'AUTOSAR-ENGINEERING-OBJECT': self._read_autosar_engineering_object,
+            'CODE': self._read_code,
 
             # DataType and DataDictionary elements
             'APPLICATION-ARRAY-DATA-TYPE': self._read_application_array_data_type,
@@ -152,6 +154,7 @@ def __init__(self,
             # Software component elements
             'APPLICATION-SW-COMPONENT-TYPE': self._read_application_sw_component_type,
             'COMPOSITION-SW-COMPONENT-TYPE': self._read_composition_sw_component_type,
+            'SWC-IMPLEMENTATION': self._read_swc_implementation,
 
         }
         # Value specification elements
@@ -1422,6 +1425,73 @@ def _read_data_filter(self, xml_element: ElementTree.Element) -> ar_element.Data
         self._report_unprocessed_elements(child_elements)
         return ar_element.DataFilter(**data)
 
+    def _read_engineering_object(self, child_elements: ChildElementMap, data: dict) -> None:
+        """
+        Reads group AR:ENGINEERING-OBJECT
+        """
+        xml_child = child_elements.get("SHORT-LABEL")
+        if xml_child is not None:
+            data["label"] = xml_child.text
+        xml_child = child_elements.get("CATEGORY")
+        if xml_child is not None:
+            data["category"] = xml_child.text
+
+    def _read_autosar_engineering_object(self, xml_element: ElementTree.Element) -> ar_element.AutosarEngineeringObject:
+        """
+        Complex type AR:AUTOSAR-ENGINEERING-OBJECT
+        Tag variants: 'AUTOSAR-ENGINEERING-OBJECT' | 'ARTIFACT-DESCRIPTOR'
+        """
+        data = {}
+        child_elements = ChildElementMap(xml_element)
+        self._read_engineering_object(child_elements, data)
+        self._report_unprocessed_elements(child_elements)
+        return ar_element.AutosarEngineeringObject(**data)
+
+    def _read_code(self, xml_element: ElementTree.Element) -> ar_element.Code:
+        """
+        Reads complex type AR:CODE
+        Tag variants: 'CODE'
+        """
+        data = {}
+        child_elements = ChildElementMap(xml_element)
+        self._read_referrable(child_elements, data)
+        self._read_multi_language_referrable(child_elements, data)
+        self._read_identifiable(child_elements, xml_element.attrib, data)
+        xml_child = child_elements.get('ARTIFACT-DESCRIPTORS')
+        if xml_child is not None:
+            elements = []
+            for xml_grand_child in xml_child.findall("./AUTOSAR-ENGINEERING-OBJECT"):
+                elements.append(self._read_autosar_engineering_object(xml_grand_child))
+            data["artifact_descriptors"] = elements
+        child_elements.skip('CALLBACK-HEADER-REFS')  # Not yet supported
+        self._report_unprocessed_elements(child_elements)
+        return ar_element.Code(**data)
+
+    def _read_implementation(self, child_elements: ChildElementMap, data: dict) -> None:
+        """
+        Reads group AR:IMPLEMENTATION
+        """
+        child_elements.skip("BUILD-ACTION-MANIFESTS")
+        xml_child = child_elements.get("CODE-DESCRIPTORS")
+        if xml_child is not None:
+            elements = []
+            for xml_grand_child in xml_child.findall("./CODE"):
+                elements.append(self._read_code(xml_grand_child))
+            data["code_descriptors"] = elements
+        child_elements.skip("COMPILERS")
+        child_elements.skip("GENERATED-ARTIFACTS")
+        child_elements.skip("HW-ELEMENT-REFS")
+        child_elements.skip("LINKERS")
+        child_elements.skip("MC-SUPPORT")
+        child_elements.skip("PROGRAMMING-LANGUAGE")
+        child_elements.skip("REQUIRED-ARTIFACTS")
+        child_elements.skip("REQUIRED-GENERATOR-TOOLS")
+        child_elements.skip("RESOURCE-CONSUMPTION")
+        child_elements.skip("SW-VERSION")
+        child_elements.skip("SWC-BSW-MAPPING-REF")
+        child_elements.skip("USED-CODE-GENERATOR")
+        child_elements.skip("VENDOR-ID")
+
     # Data type elements
 
     def _read_sw_addr_method(self, xml_element: ElementTree.Element) -> ar_element.SwAddrMethod:
@@ -2476,6 +2546,19 @@ def _read_sw_component_prototype_ref(self,
             raise ar_exception.ParseError(msg)
         return ar_element.SwComponentPrototypeRef(xml_elem.text)
 
+    def _read_swc_internal_behavior_ref(self,
+                                        xml_elem: ElementTree.Element
+                                        ) -> ar_element.SwcInternalBehaviorRef:
+        """
+        Reads reference to references to SWC-INTERNAL-BEHAVIOR--SUBTYPES-ENUM
+        """
+        data = {}
+        self._read_base_ref_attributes(xml_elem.attrib, data)
+        if data['dest'] != 'SWC-INTERNAL-BEHAVIOR':
+            msg = f"Invalid value for DEST. Expected 'SWC-INTERNAL-BEHAVIOR', got '{data['dest']}'"
+            raise ar_exception.ParseError(msg)
+        return ar_element.SwcInternalBehaviorRef(xml_elem.text)
+
 # --- Constant and value specifications
 
     def _read_text_value_specification(self,
@@ -4090,6 +4173,35 @@ def _read_composition_sw_component_type_group(self, child_elements: ChildElement
         child_elements.skip("DATA-TYPE-MAPPING-REFS")
         child_elements.skip("INSTANTIATION-RTE-EVENT-PROPSS")
 
+    def _read_swc_implementation(self,
+                                 xml_element: ElementTree.Element
+                                 ) -> ar_element.SwcImplementation:
+        """
+        Reads complex type AR:SWC-IMPLEMENTATION
+        Tag variants: 'SWC-IMPLEMENTATION'
+        """
+        data = {}
+        child_elements = ChildElementMap(xml_element)
+        self._read_referrable(child_elements, data)
+        self._read_multi_language_referrable(child_elements, data)
+        self._read_identifiable(child_elements, xml_element.attrib, data)
+        self._read_implementation(child_elements, data)
+        self._read_swc_implementation_group(child_elements, data)
+        self._report_unprocessed_elements(child_elements)
+        return ar_element.SwcImplementation(**data)
+
+    def _read_swc_implementation_group(self, child_elements: ChildElementMap, data: dict) -> None:
+        """
+        Reads group AR:COMPOSITION-SW-COMPONENT-TYPE
+        """
+        xml_child = child_elements.get("BEHAVIOR-REF")
+        if xml_child is not None:
+            data["behavior_ref"] = self._read_swc_internal_behavior_ref(xml_child)
+        child_elements.skip("PER-INSTANCE-MEMORY-SIZES")  # Not yet supported
+        xml_child = child_elements.get("REQUIRED-RTE-VENDOR")
+        if xml_child is not None:
+            data["required_rte_vendor"] = xml_child.text
+
     # --- Internal Behavior elements
 
     def _read_variable_in_impl_data_instance_ref(self,