Implement PortApiOption classes

Conny Gustafsson · Conny Gustafsson · commit 4a53bd2c9cad · 2025-01-24T15:18:08.000+01:00
- CommunicationBufferLocking
- PortDefinedArgumentValue
- PortApiOption
diff --git a/.pylintrc b/.pylintrc
@@ -516,7 +516,8 @@ exclude-too-few-public-methods=
 ignored-parents=
 
 # Maximum number of arguments for function / method.
-max-args=5
+max-args=12
+max-positional-arguments=12
 
 # Maximum number of attributes for a class (see R0902).
 max-attributes=7
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,10 +1,20 @@
 # Changelog
 
-The first name in a bullet point below is the Python class name while the second name is the identifier used in the XML schema (XSD file).
+The first name in a bullet point below is the Python class name while the second name is the complex type in the AUTOSAR XML schema (XSD file).
 
-Elements marked as `collectable` means that they can be added directly to a package.
+Elements marked as `collectable` means that they are allowed to be added as sub-elements in a package.
 Non-collectable elements are various sub-elements to collectable elements.
 
+## [Unreleased]
+
+### Added
+
+#### XML - SWC internal behavior elements
+
+* CommunicationBufferLocking | COMMUNICATION-BUFFER-LOCKING
+* PortAPIOption | PORT-API-OPTION
+* PortDefinedArgumentValue | PORT-DEFINED-ARGUMENT-VALUE
+
 ## [v0.5.4] - 2024-10-28
 
 ### Added
diff --git a/src/autosar/xml/element.py b/src/autosar/xml/element.py
@@ -1632,7 +1632,7 @@ class SwDataDefPropsConditional(ARObject):
     Tag Variants: SW-DATA-DEF-PROPS-CONDITIONAL
     """
 
-    def __init__(self,
+    def __init__(self,  # pylint: disable=R0917
                  display_presentation: ar_enum.DisplayPresentation | None = None,
                  step_size: float | None = None,
                  annotations: Annotation | list[Annotation] | None = None,
@@ -3757,7 +3757,7 @@ class EndToEndTransformationComSpecProps(Describable):
     Tag variants: 'END-TO-END-TRANSFORMATION-COM-SPEC-PROPS'
     """
 
-    def __init__(self,
+    def __init__(self,  # pylint: disable=R0917
                  clear_from_valid_to_invalid: bool | None = None,
                  disable_e2e_check: bool | None = None,
                  disable_e2e_state_machine: bool | None = None,
@@ -5815,6 +5815,7 @@ def __init__(self,
         self.disabled_modes: list[RModeInAtomicSwcInstanceRef] = []
         # .START-ON-EVENT-REF
         self.start_on_event: RunnableEntityRef | None = None
+
         if disabled_modes is not None:
             if isinstance(disabled_modes, RModeInAtomicSwcInstanceRef):
                 self.append_disabled_mode(disabled_modes)
@@ -6221,12 +6222,101 @@ def __init__(self,
         self._assign_optional("value_type", value_type, ImplementationDataTypeRef)
 
 
+class SwcSupportedFeature(ARObject):
+    """
+    Base class for supported features
+    """
+
+
+class CommunicationBufferLocking(SwcSupportedFeature):
+    """
+    Complex type AR:COMMUNICATION-BUFFER-LOCKING
+    Tag variantS: 'COMMUNICATION-BUFFER-LOCKING'
+    """
+
+    def __init__(self,
+                 support_buffer_locking: ar_enum.SupportBufferLocking | None = None) -> None:
+        super().__init__()
+        # .SUPPORT-BUFFER-LOCKING
+        self.support_buffer_locking: ar_enum.SupportBufferLocking = None
+
+        self._assign_optional("support_buffer_locking", support_buffer_locking, ar_enum.SupportBufferLocking)
+
+
+PortDefinedArgumentValueArgType = PortDefinedArgumentValue | list[PortDefinedArgumentValue] | None
+SwcSupportedFeatureArgType = SwcSupportedFeature | list[SwcSupportedFeature] | None
+
+
 class PortAPIOption(ARObject):
     """
     Complex type AR:PORT-API-OPTION
     Tag variants: 'PORT-API-OPTION'
     """
 
+    def __init__(self,
+                 enable_take_address: bool | None = None,
+                 error_handling: ar_enum.DataTransformationErrorHandling | None = None,
+                 indirect_api: bool | None = None,
+                 port_arg_values: PortDefinedArgumentValueArgType = None,
+                 port: PortPrototypeRef | None = None,
+                 supported_features: SwcSupportedFeatureArgType = None,
+                 transformer_status_forwarding: ar_enum.DataTransformationStatusForwarding | None = None
+                 ) -> None:
+        super().__init__()
+        # .ENABLE-TAKE-ADDRESS
+        self.enable_take_address: bool | None = None
+        # .ERROR-HANDLING
+        self.error_handling: ar_enum.DataTransformationErrorHandling | None = None
+        # .INDIRECT-API
+        self.indirect_api: bool | None = None
+        # .PORT-ARG-VALUES
+        self.port_arg_values: list[PortDefinedArgumentValue] = []
+        # .PORT-REF
+        self.port: PortPrototypeRef | None = port
+        # .SUPPORTED-FEATURES
+        self.supported_features: list[SwcSupportedFeature] = []
+        # .TRANSFORMER-STATUS-FORWARDING
+        self.transformer_status_forwarding: ar_enum.DataTransformationStatusForwarding | None = None
+        # .VARIATION-POINT not supported
+
+        self._assign_optional("enable_take_address", enable_take_address, bool)
+        self._assign_optional("error_handling", error_handling, ar_enum.DataTransformationErrorHandling)
+        self._assign_optional("indirect_api", indirect_api, bool)
+        self._assign_optional("port", port, PortPrototypeRef)
+        self._assign_optional("transformer_status_forwarding",
+                              transformer_status_forwarding,
+                              ar_enum.DataTransformationStatusForwarding)
+        if port_arg_values is not None:
+            if isinstance(port_arg_values, list):
+                for port_arg_value in port_arg_values:
+                    self.append_port_arg_value(port_arg_value)
+            else:
+                self.append_port_arg_value(port_arg_values)
+        if supported_features is not None:
+            if isinstance(supported_features, list):
+                for supported_feature in supported_features:
+                    self.append_supported_feature(supported_feature)
+            else:
+                self.append_supported_feature(supported_features)
+
+    def append_port_arg_value(self, port_arg_value: PortDefinedArgumentValue) -> None:
+        """
+        Adds PortDefinedArgumentValue to internal list
+        """
+        if isinstance(port_arg_value, PortDefinedArgumentValue):
+            self.port_arg_values.append(port_arg_value)
+        else:
+            raise TypeError("port_arg_value must be of type PortDefinedArgumentValue")
+
+    def append_supported_feature(self, supported_feature: SwcSupportedFeature) -> None:
+        """
+        Adds PortDefinedArgumentValue to internal list
+        """
+        if isinstance(supported_feature, (CommunicationBufferLocking,)):
+            self.supported_features.append(supported_feature)
+        else:
+            raise TypeError("supported_feature must be of type CommunicationBufferLocking")
+
 
 class InternalBehavior(Identifiable):
     """
diff --git a/src/autosar/xml/enumeration.py b/src/autosar/xml/enumeration.py
@@ -104,6 +104,22 @@ class DataFilterType(Enum):
     ONE_EVERY_N = 7
 
 
+class DataTransformationErrorHandling(Enum):
+    """
+    DATA-TRANSFORMATION-ERROR-HANDLING-ENUM--SIMPLE
+    """
+    NO_TRANSFORMER_ERROR_HANDLING = 0
+    TRANSFORMER_ERROR_HANDLING = 1
+
+
+class DataTransformationStatusForwarding(Enum):
+    """
+    DATA-TRANSFORMATION-STATUS-FORWARDING-ENUM--SIMPLE
+    """
+    NO_TRANSFORMER_STATUS_FORWARDING = 0
+    TRANSFORMER_STATUS_FORWARDING = 1
+
+
 class DisplayPresentation(Enum):
     """DISPLAY-PRESENTATION-ENUM"""
 
@@ -546,6 +562,14 @@ class ServiceKind(Enum):
     WATCH_DOG_MANAGER = 17
 
 
+class SupportBufferLocking(Enum):
+    """
+    SUPPORT-BUFFER-LOCKING-ENUM--SIMPLE
+    """
+    DOES_NOT_SUPPORT_BUFFER_LOCKING = 0
+    SUPPORTS_BUFFER_LOCKING = 1
+
+
 class SwCalibrationAccess(Enum):
     """
     AR:SW-CALIBRATION-ACCESS-ENUM--SIMPLE
@@ -679,6 +703,14 @@ class VersionedTextValue:
         "ONE-EVERY-N": DataFilterType.ONE_EVERY_N
 
     },
+    "DataTransformationErrorHandling": {
+        "NO-TRANSFORMER-ERROR-HANDLING": DataTransformationErrorHandling.NO_TRANSFORMER_ERROR_HANDLING,
+        "TRANSFORMER-ERROR-HANDLING": DataTransformationErrorHandling.TRANSFORMER_ERROR_HANDLING
+    },
+    "DataTransformationStatusForwarding": {
+        "NO-TRANSFORMER-STATUS-FORWARDING": DataTransformationStatusForwarding.NO_TRANSFORMER_STATUS_FORWARDING,
+        "TRANSFORMER-STATUS-FORWARDING": DataTransformationStatusForwarding.TRANSFORMER_STATUS_FORWARDING
+    },
     "DisplayPresentation": {
         "PRESENTATION-CONTINUOUS": DisplayPresentation.CONTINUOUS,
         "PRESENTATION-DISCRETE": DisplayPresentation.DISCRETE
@@ -968,6 +1000,10 @@ class VersionedTextValue:
         "USE-ARRAY-BASE-TYPE": ServerArgImplPolicy.USE_ARRAY_BASED_TYPE,
         "USE-VOID": ServerArgImplPolicy.USE_VOID
     },
+    "SupportBufferLocking": {
+        "DOES-NOT-SUPPORT-BUFFER-LOCKING": SupportBufferLocking.DOES_NOT_SUPPORT_BUFFER_LOCKING,
+        "SUPPORTS-BUFFER-LOCKING": SupportBufferLocking.SUPPORTS_BUFFER_LOCKING
+    },
     "SwCalibrationAccess": {
         "NOT-ACCESSIBLE": SwCalibrationAccess.NOT_ACCESSIBLE,
         "READ-ONLY": SwCalibrationAccess.READ_ONLY,
@@ -1043,6 +1079,14 @@ def xml_to_enum(enum_type_name: str, xml_text: str, schema_version: int = ar_bas
         "RES-AXIS",    # 3
         "STD-AXIS"     # 4
     ],
+    "DataTransformationErrorHandling": [
+        "NO-TRANSFORMER-ERROR-HANDLING",
+        "TRANSFORMER-ERROR-HANDLING"
+    ],
+    "DataTransformationStatusForwarding": [
+        "NO-TRANSFORMER-STATUS-FORWARDING",
+        "TRANSFORMER-STATUS-FORWARDING"
+    ],
     "DataFilterType": [
         "ALWAYS",                         # 0
         "MASKED-NEW-DIFFERS-MASKED-OLD",  # 1
@@ -1343,6 +1387,10 @@ def xml_to_enum(enum_type_name: str, xml_text: str, schema_version: int = ar_bas
         "USE-ARRAY-BASE-TYPE",  # 1
         "USE-VOID",             # 2
     ],
+    "SupportBufferLocking": [
+        "DOES-NOT-SUPPORT-BUFFER-LOCKING",  # 0
+        "SUPPORTS-BUFFER-LOCKING"           # 1
+    ],
     "SwCalibrationAccess": [
         "NOT-ACCESSIBLE",  # 0
         "READ-ONLY",       # 1
diff --git a/src/autosar/xml/reader.py b/src/autosar/xml/reader.py
@@ -318,6 +318,8 @@ def __init__(self,
             '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,
+            'COMMUNICATION-BUFFER-LOCKING': self._read_communication_buffer_locking,
+            'PORT-API-OPTION': self._read_port_api_option,
         }
         self.switcher_all = {}
         self.switcher_all.update(self.switcher_collectable)
@@ -5098,6 +5100,71 @@ def _read_port_defined_argument_value(self,
         self._report_unprocessed_elements(child_elements)
         return ar_element.PortDefinedArgumentValue(**data)
 
+    def _read_communication_buffer_locking(self,
+                                           xml_element: ElementTree.Element
+                                           ) -> ar_element.CommunicationBufferLocking:
+        """
+        Reads complex type AR:COMMUNICATION-BUFFER-LOCKING
+        Tag variantS: 'COMMUNICATION-BUFFER-LOCKING'
+        """
+        data = {}
+        child_elements = ChildElementMap(xml_element)
+        xml_child = child_elements.get("SUPPORT-BUFFER-LOCKING")
+        if xml_child is not None:
+            data["support_buffer_locking"] = ar_enum.xml_to_enum("SupportBufferLocking", xml_child.text)
+        self._report_unprocessed_elements(child_elements)
+        return ar_element.CommunicationBufferLocking(**data)
+
+    def _read_port_api_option(self,
+                              xml_element: ElementTree.Element
+                              ) -> ar_element.PortAPIOption:
+        """
+        Reads complex type AR:PORT-API-OPTION
+        Tag variants: 'PORT-API-OPTION'
+        """
+        data = {}
+        child_elements = ChildElementMap(xml_element)
+        self._read_port_api_option_group(child_elements, data)
+        self._report_unprocessed_elements(child_elements)
+        return ar_element.PortAPIOption(**data)
+
+    def _read_port_api_option_group(self, child_elements: ChildElementMap, data: dict) -> None:
+        """
+        Reads group AR:PORT-API-OPTION
+        """
+        xml_child = child_elements.get("ENABLE-TAKE-ADDRESS")
+        if xml_child is not None:
+            data["enable_take_address"] = self._read_boolean(xml_child.text)
+        xml_child = child_elements.get("ERROR-HANDLING")
+        if xml_child is not None:
+            data["error_handling"] = ar_enum.xml_to_enum("DataTransformationErrorHandling", xml_child.text)
+        xml_child = child_elements.get("INDIRECT-API")
+        if xml_child is not None:
+            data["indirect_api"] = self._read_boolean(xml_child.text)
+        xml_child = child_elements.get("PORT-ARG-VALUES")
+        if xml_child is not None:
+            port_arg_values = []
+            for xml_grand_child in xml_child.findall("./PORT-DEFINED-ARGUMENT-VALUE"):
+                port_arg_values.append(self._read_port_defined_argument_value(xml_grand_child))
+            data["port_arg_values"] = port_arg_values
+        xml_child = child_elements.get("PORT-REF")
+        if xml_child is not None:
+            data["port"] = self._read_port_prototype_ref(xml_child)
+        xml_child = child_elements.get("PORT-REF")
+        if xml_child is not None:
+            data["port"] = self._read_port_prototype_ref(xml_child)
+        xml_child = child_elements.get("SUPPORTED-FEATURES")
+        if xml_child is not None:
+            supported_features = []
+            for xml_grand_child in xml_child.findall("./*"):
+                if xml_grand_child.tag == "COMMUNICATION-BUFFER-LOCKING":
+                    supported_features.append(self._read_communication_buffer_locking(xml_grand_child))
+            data["supported_features"] = supported_features
+        xml_child = child_elements.get("TRANSFORMER-STATUS-FORWARDING")
+        if xml_child is not None:
+            data["transformer_status_forwarding"] = ar_enum.xml_to_enum("DataTransformationStatusForwarding",
+                                                                        xml_child.text)
+
     def _read_swc_internal_behavior(self, xml_element: ElementTree.Element) -> ar_element.SwcInternalBehavior:
         """
         Reads complex type AR:SWC-INTERNAL-BEHAVIOR
diff --git a/src/autosar/xml/writer.py b/src/autosar/xml/writer.py
diff --git a/tests/xml/test_swc_internal_behavior.py b/tests/xml/test_swc_internal_behavior.py
