Implement PortDefinedArgumentValue

Author: Conny Gustafsson

run_examples.sh

@@ -6202,6 +6202,32 @@ def __init__(self,
         self._assign_optional_strict("trigger", trigger, PTriggerInAtomicSwcTypeInstanceRef)
 
 
+class PortDefinedArgumentValue(ARObject):
+    """
+    Complex type AR:PORT-DEFINED-ARGUMENT-VALUE
+    Tag variantS: 'PORT-DEFINED-ARGUMENT-VALUE'
+    """
+
+    def __init__(self,
+                 value: ValueSpecificationElement | None = None,
+                 value_type: ImplementationDataTypeRef | str | None = None) -> None:
+        super().__init__()
+        # .VALUE
+        self.value: ValueSpecificationElement | None = None
+        # .VALUE-TYPE-TREF
+        self.value_type: ImplementationDataTypeRef | None = None
+
+        self._assign_optional_strict("value", value, ValueSpecification)
+        self._assign_optional("value_type", value_type, ImplementationDataTypeRef)
+
+
+class PortAPIOption(ARObject):
+    """
+    Complex type AR:PORT-API-OPTION
+    Tag variants: 'PORT-API-OPTION'
+    """
+
+
 class InternalBehavior(Identifiable):
     """
     Group AR:INTERNAL-BEHAVIOR

run_flake.sh

@@ -317,6 +317,7 @@ def __init__(self,
             'SWC-MODE-SWITCH-EVENT': self._read_swc_mode_switch_event,
             'TIMING-EVENT': self._read_timing_event,
             'TRANSFORMER-HARD-ERROR-EVENT': self._read_transformer_hard_error_event,
+            'PORT-DEFINED-ARGUMENT-VALUE': self._read_port_defined_argument_value,
         }
         self.switcher_all = {}
         self.switcher_all.update(self.switcher_collectable)
@@ -5047,7 +5048,7 @@ def _read_transformer_hard_error_event(self,
                                            xml_element: ElementTree.Element
                                            ) -> ar_element.TransformerHardErrorEvent:
         """
-        Writes complex type AR:TRANSFORMER-HARD-ERROR-EVENT
+        Reads complex type AR:TRANSFORMER-HARD-ERROR-EVENT
         Tag variants: 'TRANSFORMER-HARD-ERROR-EVENT'
         """
         data = {}
@@ -5074,6 +5075,29 @@ def _read_transformer_hard_error_event_group(self, child_elements: ChildElementM
         if xml_child is not None:
             data["trigger"] = self._read_p_trigger_in_atomic_swc_instance_ref(xml_child)
 
+    def _read_port_defined_argument_value(self,
+                                          xml_element: ElementTree.Element
+                                          ) -> ar_element.PortDefinedArgumentValue:
+        """
+        Reads complex type AR:PORT-DEFINED-ARGUMENT-VALUE
+        Tag variants: 'PORT-DEFINED-ARGUMENT-VALUE'
+        """
+        data = {}
+        child_elements = ChildElementMap(xml_element)
+        xml_child = child_elements.get("VALUE")
+        if xml_child is not None:
+            try:
+                xml_grand_child = xml_child.find("./*")
+                if xml_grand_child is not None:
+                    data["value"] = self._read_value_specification_element(xml_grand_child)
+            except KeyError:
+                pass
+        xml_child = child_elements.get("VALUE-TYPE-TREF")
+        if xml_child is not None:
+            data["value_type"] = self._read_impl_data_type_ref(xml_child)
+        self._report_unprocessed_elements(child_elements)
+        return ar_element.PortDefinedArgumentValue(**data)
+
     def _read_swc_internal_behavior(self, xml_element: ElementTree.Element) -> ar_element.SwcInternalBehavior:
         """
         Reads complex type AR:SWC-INTERNAL-BEHAVIOR

run_tests.sh

@@ -372,6 +372,7 @@ def __init__(self,
             'SwcModeSwitchEvent': self._write_swc_mode_switch_event,
             'TimingEvent': self._write_timing_event,
             'TransformerHardErrorEvent': self._write_transformer_hard_error_event,
+            'PortDefinedArgumentValue': self._write_port_defined_argument_value,
         }
         self.switcher_all = {}  # All concrete elements (used for unit testing)
         self.switcher_all.update(self.switcher_collectable)
@@ -1467,7 +1468,7 @@ def _write_sw_data_def_props_content(self, elem: ar_element.SwDataDefPropsCondit
         if elem.data_constraint_ref is not None:
             self._write_data_constraint_ref(elem.data_constraint_ref)
         if elem.impl_data_type_ref is not None:
-            self._write_impl_data_type_ref(elem.impl_data_type_ref)
+            self._write_impl_data_type_ref(elem.impl_data_type_ref, "IMPLEMENTATION-DATA-TYPE-REF")
         if elem.impl_policy is not None:
             self._add_content('SW-IMPL-POLICY',
                               ar_enum.enum_to_xml(elem.impl_policy))
@@ -1792,7 +1793,7 @@ def _write_data_type_map(self, elem: ar_element.DataTypeMap) -> None:
         if elem.appl_data_type_ref is not None:
             self._write_application_data_type_ref(elem.appl_data_type_ref, "APPLICATION-DATA-TYPE-REF")
         if elem.impl_data_type_ref is not None:
-            self._write_impl_data_type_ref(elem.impl_data_type_ref)
+            self._write_impl_data_type_ref(elem.impl_data_type_ref, "IMPLEMENTATION-DATA-TYPE-REF")
         self._leave_child()
 
     def _write_data_type_mapping_set(self, elem: ar_element.DataTypeMappingSet) -> None:
@@ -1986,19 +1987,18 @@ def _write_function_ptr_signature_ref(self, elem: ar_element.FunctionPtrSignatur
         self._collect_base_ref_attr(elem, attr)
         self._add_content('FUNCTION-POINTER-SIGNATURE-REF', elem.value, attr)
 
-    def _write_impl_data_type_ref(self, elem: ar_element.ImplementationDataTypeRef) -> None:
+    def _write_impl_data_type_ref(self, elem: ar_element.ImplementationDataTypeRef, tag: str) -> None:
         """
-        Writes complex type AR:IMPLEMENTATION-DATA-TYPE-REF
-        Type: Concrete
-        Tag variants: 'IMPLEMENTATION-DATA-TYPE-REF'
+        Writes reference to AR:IMPLEMENTATION-DATA-TYPE-REF
+        Tag variants: 'IMPLEMENTATION-DATA-TYPE-REF' | 'VALUE-TYPE-TREF'
 
         Note: The name of the complex-type is anonymous in the XML schema.
 
         """
         assert isinstance(elem, ar_element.ImplementationDataTypeRef)
         attr: TupleList = []
         self._collect_base_ref_attr(elem, attr)
-        self._add_content('IMPLEMENTATION-DATA-TYPE-REF', elem.value, attr)
+        self._add_content(tag, elem.value, attr)
 
     def _write_sw_base_type_ref(self, elem: ar_element.SwBaseTypeRef) -> None:
         """
@@ -2016,7 +2016,7 @@ def _write_sw_base_type_ref(self, elem: ar_element.SwBaseTypeRef) -> None:
 
     def _write_sw_addr_method_ref(self, elem: ar_element.SwAddrMethodRef) -> None:
         """
-        Writes references to AR:SW-ADDR-METHOD--SUBTYPES-ENUM
+        Writes reference to AR:SW-ADDR-METHOD--SUBTYPES-ENUM
         Tag variants: 'SW-ADDR-METHOD-REF'
         """
         assert isinstance(elem, ar_element.SwAddrMethodRef)
@@ -4351,6 +4351,25 @@ def _write_transformer_hard_error_event_group(self, elem: ar_element.Transformer
         if elem.trigger is not None:
             self._write_p_trigger_in_atomic_swc_instance_ref(elem.trigger, "TRIGGER-IREF")
 
+    def _write_port_defined_argument_value(self, elem: ar_element.PortDefinedArgumentValue) -> None:
+        """
+        Writes complex type AR:PORT-DEFINED-ARGUMENT-VALUE
+        Tag variants: 'PORT-DEFINED-ARGUMENT-VALUE'
+        """
+        assert isinstance(elem, ar_element.PortDefinedArgumentValue)
+        tag = "PORT-DEFINED-ARGUMENT-VALUE"
+        if elem.is_empty:
+            self._add_content(tag)
+        else:
+            self._add_child(tag)
+            if elem.value is not None:
+                self._add_child("VALUE")
+                self._write_value_specification_element(elem.value)
+                self._leave_child()
+            if elem.value_type is not None:
+                self._write_impl_data_type_ref(elem.value_type, "VALUE-TYPE-TREF")
+            self._leave_child()
+
     def _write_swc_internal_behavior(self, elem: ar_element.SwcInternalBehavior) -> None:
         """
         Writes complex type AR:SWC-INTERNAL-BEHAVIOR

src/autosar/xml/element.py

@@ -1664,6 +1664,48 @@ def test_trigger(self):
         self.assertEqual(str(inner.target_trigger), target_trigger_ref_str)
 
 
+class TestPortDefinedArgumentValue(unittest.TestCase):
+    def test_empty(self):
+        element = ar_element.PortDefinedArgumentValue()
+        writer = autosar.xml.Writer()
+        xml = writer.write_str_elem(element)
+        self.assertEqual(xml, '<PORT-DEFINED-ARGUMENT-VALUE/>')
+        reader = autosar.xml.Reader()
+        elem: ar_element.PortDefinedArgumentValue = reader.read_str_elem(xml)
+        self.assertIsInstance(elem, ar_element.PortDefinedArgumentValue)
+
+    def test_value(self):
+        value = ar_element.NumericalValueSpecification(value=10)
+        element = ar_element.PortDefinedArgumentValue(value=value)
+        writer = autosar.xml.Writer()
+        xml = '''<PORT-DEFINED-ARGUMENT-VALUE>
+  <VALUE>
+    <NUMERICAL-VALUE-SPECIFICATION>
+      <VALUE>10</VALUE>
+    </NUMERICAL-VALUE-SPECIFICATION>
+  </VALUE>
+</PORT-DEFINED-ARGUMENT-VALUE>'''
+        self.assertEqual(writer.write_str_elem(element), xml)
+        reader = autosar.xml.Reader()
+        elem: ar_element.PortDefinedArgumentValue = reader.read_str_elem(xml)
+        self.assertIsInstance(elem.value, ar_element.NumericalValueSpecification)
+        self.assertEqual(elem.value.value, 10)
+
+    def test_value_type(self):
+        ref_str = "/DataTypes/TypeName"
+        impl_type_ref = ar_element.ImplementationDataTypeRef(ref_str)
+        element = ar_element.PortDefinedArgumentValue(value_type=impl_type_ref)
+        writer = autosar.xml.Writer()
+        xml = f'''<PORT-DEFINED-ARGUMENT-VALUE>
+  <VALUE-TYPE-TREF DEST="IMPLEMENTATION-DATA-TYPE">{ref_str}</VALUE-TYPE-TREF>
+</PORT-DEFINED-ARGUMENT-VALUE>'''
+        self.assertEqual(writer.write_str_elem(element), xml)
+        reader = autosar.xml.Reader()
+        elem: ar_element.PortDefinedArgumentValue = reader.read_str_elem(xml)
+        self.assertIsInstance(elem.value_type, ar_element.ImplementationDataTypeRef)
+        self.assertEqual(str(elem.value_type), ref_str)
+
+
 class TestSwcInternalBehavior(unittest.TestCase):
     """
     Most elements are not implemented yet