armodel 1.4.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

armodel/parser/arxml_parser.py

@@ -1,14 +1,32 @@
+from typing import List
 import xml.etree.ElementTree as ET
-
-from armodel.models.bsw_module_template import BswModeSenderPolicy
-
-from .abstract_arxml_parser import AbstractARXMLParser
-
-from ..models.port_interface import ModeSwitchInterface, PortInterface
-from ..models.common_structure import MemorySection, ModeDeclarationGroup, ModeDeclarationGroupPrototype, ModeRequestTypeMap
+import os
+
+from ..models.m2.autosar_templates.common_structure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference, NumericalValueSpecification, RecordValueSpecification, TextValueSpecification, ValueSpecification
+from ..models.m2.autosar_templates.sw_component_template.components.instance_refs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior import RunnableEntityArgument
+from ..models.m2.msr.data_dictionary.data_def_properties import SwDataDefProps
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior.mode_declaration_group import ModeAccessPoint, ModeSwitchPoint
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior.server_call import ServerCallPoint
+from ..models.m2.autosar_templates.sw_component_template.communication import ClientComSpec, ModeSwitchSenderComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, QueuedSenderComSpec, ReceiverComSpec, SenderComSpec, ServerComSpec
+from ..models.fibex.lin_communication import LinFrameTriggering
+from ..models.fibex.fibex_core.core_topology import AbstractCanCluster, CanPhysicalChannel, CommunicationCluster, LinPhysicalChannel, PhysicalChannel
+from ..models.m2.msr.documentation.block_elements import DocumentationBlock
+from ..models.m2.autosar_templates.system_template import System, SystemMapping
+from ..models.m2.autosar_templates.system_template.data_mapping import SenderReceiverToSignalGroupMapping, SenderReceiverToSignalMapping
+from ..models.m2.autosar_templates.system_template.network_management import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmNode
+from ..models.fibex.can_communication import CanFrameTriggering, RxIdentifierRange
+from ..models.m2.autosar_templates.ecuc_description_template import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue, EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue, EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
+from ..models.fibex.fibex_4_multiplatform import ISignalMapping
+from ..models.fibex.fibex_core.core_communication import Frame, FrameTriggering, IPdu, ISignalIPdu, ISignalTriggering, PduTriggering
+from ..models.internal_behavior import IncludedDataTypeSet
+from ..models.timing import ExecutionOrderConstraint, TimingExtension
+from ..models.bsw_module_template import BswModeSenderPolicy
+from ..models.m2.autosar_templates.sw_component_template.port_interface import InvalidationPolicy, ModeSwitchInterface, PortInterface
+from ..models.common_structure import IncludedModeDeclarationGroupSet, MemorySection, ModeDeclarationGroup, ModeDeclarationGroupPrototype, ModeRequestTypeMap
 from ..models.implementation import BswImplementation, EngineeringObject
 from ..models.general_structure import MultilanguageReferrable
-from ..models.multilanguage_data import LOverviewParagraph, MultiLanguageOverviewParagraph, LLongName, MultilanguageLongName
+from ..models.multilanguage_data import LOverviewParagraph, MultiLanguageOverviewParagraph, LLongName, MultiLanguageParagraph, MultilanguageLongName
 from ..models.data_def_properties import ValueList
 from ..models.record_layout import SwRecordLayoutGroup, SwRecordLayoutGroupContent, SwRecordLayoutV
 from ..models.datatype import ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, AutosarDataType, BaseTypeDirectDefinition
@@ -19,20 +37,18 @@ from ..models.service_mapping import RoleBasedPortAssignment
 from ..models.ar_package import AUTOSAR, ARPackage
 from ..models.ar_object import ARLiteral
 from ..models.service_needs import RoleBasedDataAssignment
-from ..models.ar_ref import ApplicationCompositeElementInPortInterfaceInstanceRef, InnerPortGroupInCompositionInstanceRef, VariableDataPrototypeInSystemInstanceRef, VariableInAtomicSWCTypeInstanceRef, AutosarParameterRef
+from ..models.ar_ref import AnyInstanceRef, ApplicationCompositeElementInPortInterfaceInstanceRef, InnerPortGroupInCompositionInstanceRef, RefType, VariableDataPrototypeInSystemInstanceRef, VariableInAtomicSWCTypeInstanceRef, AutosarParameterRef
 from ..models.sw_component import AtomicSwComponentType, CompositionSwComponentType, PortAPIOption, PortDefinedArgumentValue, PortGroup, ServiceDependency, SwComponentType, SwcServiceDependency
-from ..models.data_prototype import ApplicationCompositeElementDataPrototype, AutosarDataPrototype, DataPrototype
-from ..models.port_prototype import QueuedReceiverComSpec
+from ..models.data_prototype import ApplicationCompositeElementDataPrototype, AutosarDataPrototype, DataPrototype, ParameterDataPrototype, VariableDataPrototype
+from ..models.port_prototype import ModeSwitchReceiverComSpec, QueuedReceiverComSpec
 from ..models.annotation import Annotation, GeneralAnnotation
 from ..models.global_constraints import InternalConstrs, DataConstr, DataConstrRule, PhysConstrs
 
-from ..models import SwcInternalBehavior, RunnableEntity, RTEEvent, ServerCallPoint, OperationInvokedEvent, DataReceivedEvent, RVariableInAtomicSwcInstanceRef
+from ..models import SwcInternalBehavior, RunnableEntity, RTEEvent, OperationInvokedEvent, DataReceivedEvent, RVariableInAtomicSwcInstanceRef
 from ..models import SwcModeSwitchEvent, RModeInAtomicSwcInstanceRef
 from ..models import AutosarVariableRef, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef
-from ..models import ImplementationDataType, SwDataDefProps, SwPointerTargetProps, DataTypeMappingSet, DataTypeMap, ImplementationDataTypeElement
+from ..models import ImplementationDataType,  SwPointerTargetProps, DataTypeMappingSet, DataTypeMap, ImplementationDataTypeElement
 from ..models import RPortPrototype, PPortPrototype
-from ..models import ReceiverComSpec, ClientComSpec, NonqueuedReceiverComSpec
-from ..models import SenderComSpec, NonqueuedSenderComSpec, ServerComSpec
 from ..models import SenderReceiverInterface, ClientServerInterface, ClientServerOperation, ArgumentDataPrototype
 from ..models import Identifiable, AdminData, Sdg, Sd
 from ..models import AssemblySwConnector, PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
@@ -42,57 +58,70 @@ from ..models import InternalBehavior, ExecutableEntity
 from ..models import Implementation, Code, AutosarEngineeringObject, ResourceConsumption
 from ..models import TransmissionAcknowledgementRequest
 from ..models import BswModuleDescription, BswInternalBehavior, BswModuleEntity, BswScheduleEvent, SwcBswMapping, SwcBswRunnableMapping
-from ..models import ValueSpecification, ApplicationValueSpecification, TextValueSpecification, NumericalValueSpecification, ArrayValueSpecification, ConstantReference
-from ..models import RecordValueSpecification
 from ..models import ApplicationRecordDataType
 from ..models import SwValueCont, SwValues
 
+from .abstract_arxml_parser import AbstractARXMLParser
+
 class ARXMLParser(AbstractARXMLParser):
     def __init__(self, options=None) -> None:
         super().__init__(options)
+
+    def getChildElementRxIdentifierRange(self, element: ET.Element, key: str) -> RxIdentifierRange:
+        child_element = self.find(element, key)
+        range = None
+        if child_element is not None:
+            range = RxIdentifierRange()
+            range.setLowerCanId(self.getChildElementOptionalNumericalValue(child_element, "LOWER-CAN-ID")) \
+                 .setUpperCanId(self.getChildElementOptionalNumericalValue(child_element, "UPPER-CAN-ID"))
+        return range
         
-    def getShortName(self, element: ET.Element) -> str:
-        child_element = self.find(element, "SHORT-NAME")
-        if child_element is None:
-            raise ValueError("Short Name is required")
-        return child_element.text
-    
     def readSd(self, element: ET.Element, sdg: Sdg):
-        for child_element in element.findall("./xmlns:SD", self.nsmap):
+        for child_element in self.findall(element, "./SD"):
             sd = Sd()
-            sd.gid = child_element.attrib['GID']
-            sd.value = child_element.text
-
+            if 'GID' in child_element.attrib:
+                sd.setGID(child_element.attrib['GID'])
+            sd.setValue(child_element.text)
             sdg.addSd(sd)
+
+    def getSdg(self, element: ET.Element) -> Sdg:
+        sdg = Sdg()
+        if 'GID' in element.attrib:
+            sdg.setGID(element.attrib["GID"])
+        self.readSd(element, sdg)
+        for child_element in self.findall(element, "SDG"):
+            sdg.addSdgContentsType(self.getSdg(child_element))
+        return sdg
     
-    def readSdg(self, element: ET.Element, admin_data: AdminData):
-        for child_element in element.findall("./xmlns:SDGS/xmlns:SDG", self.nsmap):
-            sdg = Sdg()
-            if 'GID' in child_element.attrib:
-                sdg.gid = child_element.attrib["GID"]
-            self.readSd(child_element, sdg)
-            admin_data.addSdg(sdg)
+    def readSdgs(self, element: ET.Element, admin_data: AdminData):
+        for child_element in self.findall(element, "./SDGS/SDG"):
+            admin_data.addSdg(self.getSdg(child_element))
     
     def readAdminData(self, element: ET.Element, identifiable: Identifiable):
-        child_element = element.find("./xmlns:ADMIN-DATA", self.nsmap)
+        child_element = self.find(element, "./ADMIN-DATA")
         if child_element is not None:
             self.logger.debug("readAdminData")
             admin_data = AdminData()
-            self.readSdg(child_element, admin_data)
-            identifiable.admin_data = admin_data
+            self.readSdgs(child_element, admin_data)
+            identifiable.setAdminData(admin_data)
 
     def readMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
         self.readElementAttributes(element, referrable)
-        referrable.long_name = self.getMultilanguageLongName(element, "LONG-NAME")
+        referrable.setLongName(self.getMultilanguageLongName(element, "LONG-NAME"))
     
     def readIdentifiable(self, element: ET.Element, identifiable: Identifiable):
         self.readMultilanguageReferrable(element, identifiable)
-        identifiable.category = self.getChildElementOptionalLiteral(element, "CATEGORY")
-        identifiable.desc = self.getMultiLanguageOverviewParagraph(element, "DESC")
+
+        for annotation in self.getAnnotations(element):
+            identifiable.addAnnotation(annotation)
+
+        identifiable.setCategory(self.getChildElementOptionalLiteral(element, "CATEGORY")) \
+                    .setDesc(self.getMultiLanguageOverviewParagraph(element, "DESC"))
+        
         self.readAdminData(element, identifiable)
     
     def readLLongName(self, element: ET.Element, long_name: MultilanguageLongName):
-        for child_element in element.findall("./xmlns:L-4", self.nsmap):
+        for child_element in self.findall(element, "./L-4"):
             l4 = LLongName()
             self.readElementAttributes(child_element, l4)
             l4.value = child_element.text
@@ -102,7 +131,7 @@ class ARXMLParser(AbstractARXMLParser):
     
     def getMultilanguageLongName(self, element: ET.Element, key: str) -> MultilanguageLongName:
         long_name = None
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, "./%s" % key)
         if child_element is not None:
             long_name = MultilanguageLongName()
             self.readElementAttributes(child_element, long_name)
@@ -110,7 +139,7 @@ class ARXMLParser(AbstractARXMLParser):
         return long_name
     
     def readLOverviewParagraph(self, element: ET.Element, paragraph: MultiLanguageOverviewParagraph):
-        for child_element in element.findall("./xmlns:L-2", self.nsmap):
+        for child_element in self.findall(element, "./L-2"):
             l2 = LOverviewParagraph()
             self.readElementAttributes(child_element, l2)
             l2.value = child_element.text
@@ -126,23 +155,31 @@ class ARXMLParser(AbstractARXMLParser):
             self.readElementAttributes(child_element, paragraph)
             self.readLOverviewParagraph(child_element, paragraph)
         return paragraph
-
-    def readAutosarVariableInImplDatatype(self, element: ET.Element, accessed_variable_ref: AutosarVariableRef):
-        child_element = element.find("./xmlns:ACCESSED-VARIABLE/xmlns:AUTOSAR-VARIABLE-IREF", self.nsmap)
-        if (child_element is not None):
+    
+    def getVariableInAtomicSWCTypeInstanceRef(self, element: ET.Element) -> VariableInAtomicSWCTypeInstanceRef:
+        autosar_variable_iref  = None
+        if element is not None:
             autosar_variable_iref = VariableInAtomicSWCTypeInstanceRef()
-            autosar_variable_iref.port_prototype_ref = self.getChildElementOptionalRefType(child_element, "PORT-PROTOTYPE-REF")
-            if autosar_variable_iref.port_prototype_ref is None:
-                self._raiseError("PORT-PROTOTYPE-REF of <%s> is empty." % accessed_variable_ref.parent.short_name)
-            autosar_variable_iref.target_data_prototype_ref = self.getChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF")
-            if autosar_variable_iref.target_data_prototype_ref is None:
-                self._raiseError("TARGET-DATA-PROTOTYPE-REF of <%s> is empty." % accessed_variable_ref.parent.short_name)
-            accessed_variable_ref.autosar_variable_iref = autosar_variable_iref
-
-    def readLocalVariableRef(self, element, accessed_variable_ref: AutosarVariableRef):
-        child_element = element.find("./xmlns:ACCESSED-VARIABLE", self.nsmap)
+            self.readElementAttributes(element, autosar_variable_iref)
+            autosar_variable_iref.setPortPrototypeRef(self.getChildElementOptionalRefType(element, "PORT-PROTOTYPE-REF"))
+            autosar_variable_iref.setTargetDataPrototypeRef(self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF"))
+        return autosar_variable_iref
+
+    def getAutosarVariableInImplDatatype(self, element: ET.Element) ->  AutosarVariableRef:
+        child_element = self.find(element, "ACCESSED-VARIABLE")
+        accessed_variable_ref  = None
+        if (child_element is not None):
+            accessed_variable_ref = AutosarVariableRef()
+            accessed_variable_ref.setAutosarVariableIRef(self.getVariableInAtomicSWCTypeInstanceRef(self.find(child_element, "AUTOSAR-VARIABLE-IREF")))
+        return accessed_variable_ref
+
+    def getLocalVariableRef(self, element: ET.Element) ->  AutosarVariableRef:
+        child_element = self.find(element, "ACCESSED-VARIABLE")
+        accessed_variable_ref  = None
         if (child_element is not None):
-            accessed_variable_ref.local_variable_ref = self.getChildElementOptionalRefType(child_element, "LOCAL-VARIABLE-REF")
+            accessed_variable_ref = AutosarVariableRef()
+            accessed_variable_ref.setLocalVariableRef(self.getChildElementOptionalRefType(child_element, "LOCAL-VARIABLE-REF"))
+        return accessed_variable_ref
 
     def _readVariableAccesses(self, element: ET.Element, parent: RunnableEntity, key: str):
         for child_element in element.findall("./xmlns:%s/xmlns:VARIABLE-ACCESS" % key, self.nsmap):
@@ -152,25 +189,25 @@ class ARXMLParser(AbstractARXMLParser):
 
             if (key == "DATA-RECEIVE-POINT-BY-ARGUMENTS"):
                 variable_access = parent.createDataReceivePointByArgument(short_name)
-                self.readAutosarVariableInImplDatatype(child_element, variable_access.accessed_variable_ref)
+                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
             elif (key == "DATA-RECEIVE-POINT-BY-VALUES"):
                 variable_access = parent.createDataReceivePointByValue(short_name)
-                self.readAutosarVariableInImplDatatype(child_element, variable_access.accessed_variable_ref)
+                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
             elif (key == "DATA-READ-ACCESSS"):
                 variable_access = parent.createDataReadAccess(short_name)
-                self.readAutosarVariableInImplDatatype(child_element, variable_access.accessed_variable_ref)
+                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
             elif (key == "DATA-WRITE-ACCESSS"):
                 variable_access = parent.createDataWriteAccess(short_name)
-                self.readAutosarVariableInImplDatatype(child_element, variable_access.accessed_variable_ref)
+                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
             elif (key == "DATA-SEND-POINTS"):
                 variable_access = parent.createDataSendPoint(short_name)
-                self.readAutosarVariableInImplDatatype(child_element, variable_access.accessed_variable_ref)
+                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
             elif (key == "WRITTEN-LOCAL-VARIABLES"):
                 variable_access = parent.createWrittenLocalVariable(short_name)
-                self.readLocalVariableRef(child_element, variable_access.accessed_variable_ref)
+                variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element))
             elif (key == "READ-LOCAL-VARIABLES"):
                 variable_access = parent.createReadLocalVariable(short_name)
-                self.readLocalVariableRef(child_element, variable_access.accessed_variable_ref)
+                variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element))
             else:
                 self._raiseError("Invalid key type <%s>" % key)
 
@@ -203,16 +240,15 @@ class ARXMLParser(AbstractARXMLParser):
             mode_group.type_tref = self.getChildElementRefType(parent.short_name, child_element, "TYPE-TREF")
 
     def readCanEnterExclusiveAreaRefs(self, element: ET.Element, entity: ExecutableEntity):
-        child_element = element.find("./xmlns:CAN-ENTER-EXCLUSIVE-AREA-REFS", self.nsmap)
-        if child_element is not None:
-            for ref in self.getChildElementRefTypeList(child_element, "CAN-ENTER-EXCLUSIVE-AREA-REF"):
-                entity.addCanEnterExclusiveAreaRef(ref)
+        for ref in self.getChildElementRefTypeList(element, "CAN-ENTER-EXCLUSIVE-AREA-REFS/CAN-ENTER-EXCLUSIVE-AREA-REF"):
+            entity.addCanEnterExclusiveAreaRef(ref)
 
     def readExecutableEntity(self, element: ET.Element, entity: ExecutableEntity):
         self.logger.debug("readExecutableEntity %s" % entity.short_name)
         self.readIdentifiable(element, entity)
         self.readCanEnterExclusiveAreaRefs(element, entity)
-        entity.minimum_start_interval = self.getChildElementOptionalFloatValue(element, "MINIMUM-START-INTERVAL")
+        entity.setMinimumStartInterval(self.getChildElementOptionalFloatValue(element, "MINIMUM-START-INTERVAL")) \
+              .setSwAddrMethodRef(self.getChildElementOptionalRefType(element, "SW-ADDR-METHOD-REF"))
 
     def readBswModuleEntityManagedModeGroup(self, element: ET.Element, entity: BswModuleEntity):
         for child_element in self.findall(element, "./MANAGED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE-REF-CONDITIONAL"):
@@ -222,7 +258,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
         self.readExecutableEntity(element, entity)
-        entity.implemented_entry_ref = self.getChildElementRefType(entity.short_name, element, "IMPLEMENTED-ENTRY-REF")
+        entity.setImplementedEntryRef(self.getChildElementRefType(entity.short_name, element, "IMPLEMENTED-ENTRY-REF"))
         self.readBswModuleEntityManagedModeGroup(element, entity)
 
     def readBswCalledEntity(self, element: ET.Element, parent: BswInternalBehavior):
@@ -298,11 +334,18 @@ class ARXMLParser(AbstractARXMLParser):
     def readDataTypeMappingRefs(self, element: ET.Element, behavior: InternalBehavior):
         child_element = element.find("./xmlns:DATA-TYPE-MAPPING-REFS", self.nsmap)
         if child_element is not None:
-            for ref in self.getChildElementRefTypeList(child_element, "DATA-TYPE-MAPPING-REF"):
+            for ref in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-MAPPING-REF"):
                 behavior.addDataTypeMappingRef(ref)
 
+    def readInternalBehaviorConstantMemories(self, element: ET.Element, behavior: InternalBehavior):
+        for child_element in element.findall("./xmlns:CONSTANT-MEMORYS/xmlns:PARAMETER-DATA-PROTOTYPE", self.nsmap):
+            short_name = self.getShortName(child_element)
+            prototype = behavior.createConstantMemory(short_name)
+            self.readParameterDataPrototype(child_element, prototype)
+
     def readInternalBehavior(self, element: ET.Element, behavior: InternalBehavior):
-        self.readIdentifiable(element,  behavior)
+        self.readIdentifiable(element, behavior)
+        self.readInternalBehaviorConstantMemories(element, behavior)
         for child_element in element.findall("./xmlns:EXCLUSIVE-AREAS/xmlns:EXCLUSIVE-AREA", self.nsmap):
             short_name = self.getShortName(child_element)
             behavior.createExclusiveArea(short_name)
@@ -382,8 +425,18 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self._raiseError("Unsupported Service Dependencies <%s>" % tag_name)
 
+    def getIncludedDataTypeSets(self, element: ET.Element) -> List[IncludedDataTypeSet]:
+        include_data_type_sets = []
+        for child_element in self.findall(element, "./INCLUDED-DATA-TYPE-SETS/INCLUDED-DATA-TYPE-SET"):
+            include_data_type_set = IncludedDataTypeSet()
+            self.readElementAttributes(child_element, include_data_type_set)
+            for ref_type in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-REFS/DATA-TYPE-REF"):
+                include_data_type_set.addDataTypeRef(ref_type)
+            include_data_type_sets.append(include_data_type_set)
+        return include_data_type_sets
+
     def readSwcInternalBehavior(self, element: ET.Element, parent: AtomicSwComponentType):
-        for child_element in element.findall("./xmlns:INTERNAL-BEHAVIORS/xmlns:SWC-INTERNAL-BEHAVIOR", self.nsmap):
+        for child_element in self.findall(element, "./INTERNAL-BEHAVIORS/SWC-INTERNAL-BEHAVIOR"):
             short_name = self.getShortName(child_element)
             behavior = parent.createSwcInternalBehavior(short_name)
             self.logger.debug("readSwcInternalBehavior %s" % behavior.full_name)
@@ -396,12 +449,23 @@ class ARXMLParser(AbstractARXMLParser):
             self.readSwcInternalBehaviorEvents(child_element, behavior)
             self.readSwcInternalBehaviorServiceDependencies(child_element, behavior)
             self.readExplicitInterRunnableVariables(child_element, behavior)
+            for data_type_set  in self.getIncludedDataTypeSets(child_element):
+                behavior.addIncludedDataTypeSet(data_type_set)
             behavior.handle_termination_and_restart = self.getChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART")
             self.readPerInstanceMemories(child_element, behavior)
-            self.readPerInstanceParameter(child_element, behavior)
+            self.readPerInstanceParameters(child_element, behavior)
             self.readPortAPIOptions(child_element, behavior)
             behavior.supports_multiple_instantiation = self.getChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION")
 
+    def getIncludedModeDeclarationGroupSets(self, element: ET.Element) -> List[IncludedModeDeclarationGroupSet]:
+        group_sets = []
+        for child_element in self.findall(element, "INCLUDED-MODE-DECLARATION-GROUP-SETS/INCLUDED-MODE-DECLARATION-GROUP-SET"):
+            group_set = IncludedModeDeclarationGroupSet()
+            for ref_type in self.getChildElementRefTypeList(child_element, "./MODE-DECLARATION-GROUP-REFS/MODE-DECLARATION-GROUP-REF"):
+                group_set.addModeDeclarationGroupRef(ref_type)
+            group_sets.append(group_set)
+        return group_sets
+
     def readBswInternalBehavior(self, element: ET.Element, parent: BswModuleDescription):
         for child_element in element.findall("./xmlns:INTERNAL-BEHAVIORS/xmlns:BSW-INTERNAL-BEHAVIOR", self.nsmap):
             short_name = self.getShortName(child_element)
@@ -417,6 +481,8 @@ class ARXMLParser(AbstractARXMLParser):
             self.readBswDataReceivedEvent(child_element, behavior)
             self.readBswInternalTriggerOccurredEvent(child_element, behavior)
             self.readBswInternalBehaviorModeSenderPolicy(child_element, behavior)
+            for group_set in self.getIncludedModeDeclarationGroupSets(child_element):
+                behavior.addIncludedModeDeclarationGroupSet(group_set)
 
     def readBswModuleDescription(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -510,7 +576,7 @@ class ARXMLParser(AbstractARXMLParser):
     def readBswImplementationVendorSpecificModuleDefRefs(self, element: ET.Element, parent: BswImplementation):
         child_element = element.find("./xmlns:VENDOR-SPECIFIC-MODULE-DEF-REFS", self.nsmap)
         if child_element is not None:
-            for ref in self.getChildElementRefTypeList(child_element, "VENDOR-SPECIFIC-MODULE-DEF-REF"):
+            for ref in self.getChildElementRefTypeList(child_element, "./VENDOR-SPECIFIC-MODULE-DEF-REF"):
                 parent.addVendorSpecificModuleDefRef(ref)
 
     def readBswImplementation(self, element: ET.Element, parent: ARPackage):
@@ -544,6 +610,11 @@ class ARXMLParser(AbstractARXMLParser):
     def readDataSendPoints(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-SEND-POINTS")
 
+    def getRunnableEntityArgument(self, element: ET.Element) -> RunnableEntityArgument:
+        argument = RunnableEntityArgument()
+        argument.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
+        return argument
+
     def getAutosarParameterRef(self, element: ET.Element, key: str) -> AutosarParameterRef:
         accessed_parameter = None
         child_element = element.find("./xmlns:%s" % key, self.nsmap)
@@ -571,22 +642,22 @@ class ARXMLParser(AbstractARXMLParser):
             operation_iref = ROperationInAtomicSwcInstanceRef()
             operation_iref.context_r_port_ref = self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")
             operation_iref.target_required_operation_ref = self.getChildElementOptionalRefType(child_element, "TARGET-REQUIRED-OPERATION-REF")
-            parent.operation_iref = operation_iref
+            parent.setOperationIRef(operation_iref)
 
     def readRVariableInAtomicSwcInstanceRef(self, element: ET.Element, parent: DataReceivedEvent):
-        child_element = element.find("./xmlns:DATA-IREF", self.nsmap)
+        child_element = self.find(element, "DATA-IREF")
         if (child_element is not None):
             data_iref = RVariableInAtomicSwcInstanceRef()
-            data_iref.context_r_port_ref = self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")
-            data_iref.target_data_element_ref = self.getChildElementOptionalRefType(child_element, "TARGET-DATA-ELEMENT-REF")
-            parent.data_iref = data_iref
+            data_iref.setContextRPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")) \
+                     .setTargetDataElementRef(self.getChildElementOptionalRefType(child_element, "TARGET-DATA-ELEMENT-REF"))
+            parent.setDataIRef(data_iref)
 
     def readRModeInAtomicSwcInstanceRef(self, element: ET.Element, parent: SwcModeSwitchEvent):
         for child_element in element.findall("./xmlns:MODE-IREFS/xmlns:MODE-IREF", self.nsmap):
             mode_iref = RModeInAtomicSwcInstanceRef()
-            mode_iref.context_port_ref = self.getChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF")
-            mode_iref.context_mode_declaration_group_prototype_ref = self.getChildElementRefType("", child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")
-            mode_iref.target_mode_declaration_ref = self.getChildElementRefType("", child_element, "TARGET-MODE-DECLARATION-REF")
+            mode_iref.setContextPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF")) \
+                     .setContextModeDeclarationGroupPrototypeRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")) \
+                     .setTargetModeDeclarationRef(self.getChildElementOptionalRefType(child_element, "TARGET-MODE-DECLARATION-REF"))
             parent.addModeIRef(mode_iref)
 
     def readSynchronousServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
@@ -594,7 +665,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("readSynchronousServerCallPoint %s" % short_name)
         server_call_point = parent.createSynchronousServerCallPoint(short_name)
         self.readIdentifiable(element, server_call_point)
-        server_call_point.timeout = self.getChildElementOptionalFloatValue(element, "TIMEOUT")
+        server_call_point.setTimeout(self.getChildElementOptionalFloatValue(element, "TIMEOUT"))
         self.readROperationIRef(element, "OPERATION-IREF", server_call_point)
 
     def readAsynchronousServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
@@ -602,11 +673,11 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("readAsynchronousServerCallPoint %s" % short_name)
         server_call_point = parent.createAsynchronousServerCallPoint(short_name)
         self.readIdentifiable(element, server_call_point)
-        server_call_point.timeout = self.getChildElementOptionalFloatValue(element, "TIMEOUT")
+        server_call_point.setTimeout(self.getChildElementOptionalFloatValue(element, "TIMEOUT"))
         self.readROperationIRef(element, "OPERATION-IREF", server_call_point)
 
     def readInternalBehaviorServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
-        for child_element in element.findall("./xmlns:SERVER-CALL-POINTS/*", self.nsmap):
+        for child_element in self.findall(element, "SERVER-CALL-POINTS/*"):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "SYNCHRONOUS-SERVER-CALL-POINT":
                 self.readSynchronousServerCallPoint(child_element, parent)
@@ -615,39 +686,91 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self._raiseError("Unsupported server call point type <%s>" % tag_name)
 
-    def readInternalTriggeringPoint(self, element: ET.Element, parent: RunnableEntity):
-        for child_element in element.findall("./xmlns:INTERNAL-TRIGGERING-POINTS/xmlns:INTERNAL-TRIGGERING-POINT", self.nsmap):
+    def readInternalTriggeringPoints(self, element: ET.Element, parent: RunnableEntity):
+        for child_element in self.findall(element, "INTERNAL-TRIGGERING-POINTS/INTERNAL-TRIGGERING-POINT"):
             short_name = self.getShortName(child_element)
             point = parent.createInternalTriggeringPoint(short_name)
             point.sw_impl_policy = self.getChildElementOptionalLiteral(child_element, "SW-IMPL-POLICY")
 
+    def getRModeInAtomicSwcInstanceRef(self, element: ET.Element) -> RModeInAtomicSwcInstanceRef:
+        iref = RModeInAtomicSwcInstanceRef()
+        iref.setBaseRef(self.getChildElementOptionalRefType(element, "BASE-REF")) \
+            .setContextPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")) \
+            .setContextModeDeclarationGroupPrototypeRef(self.getChildElementOptionalRefType(element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")) \
+            .setTargetModeDeclarationRef(self.getChildElementOptionalRefType(element, "TARGET-MODE-DECLARATION-REF"))
+        return iref
+    
+    def getRModeGroupInAtomicSWCInstanceRef(self, element: ET.Element) -> RModeGroupInAtomicSWCInstanceRef:
+        child_element = self.find(element, "MODE-GROUP-IREF/R-MODE-GROUP-IN-ATOMIC-SWC-INSTANCE-REF")
+        iref = None
+        if child_element is not None:
+            iref = RModeGroupInAtomicSWCInstanceRef()
+            iref.setContextRPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")) \
+                .setTargetModeGroupRef(self.getChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF"))
+        return iref
+    
+    def getPModeGroupInAtomicSWCInstanceRef(self, element: ET.Element) -> PModeGroupInAtomicSwcInstanceRef:
+        child_element = self.find(element, "MODE-GROUP-IREF")
+        iref = None
+        if child_element is not None:
+            iref = PModeGroupInAtomicSwcInstanceRef()
+            iref.setContextPPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-P-PORT-REF")) \
+                .setTargetModeGroupRef(self.getChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF"))
+        return iref
+
+    def readModeAccessPoints(self, element: ET.Element, parent: RunnableEntity):
+        for child_element in self.findall(element, "MODE-ACCESS-POINTS/MODE-ACCESS-POINT"):
+            point = ModeAccessPoint()
+            point.setModeGroupIRef(self.getRModeGroupInAtomicSWCInstanceRef(child_element))
+            parent.addModeAccessPoint(point)
+
+    def readModeSwitchPoints(self, element: ET.Element, parent: RunnableEntity):
+        for child_element in self.findall(element, "MODE-SWITCH-POINTS/MODE-SWITCH-POINT"):
+            point = parent.createModeSwitchPoint(self.getShortName(child_element))
+            point.setModeGroupIRef(self.getPModeGroupInAtomicSWCInstanceRef(child_element))
+
+    def readRunnableEntityArguments(self, element: ET.Element, entity: RunnableEntity):
+        for child_element in self.findall(element, "ARGUMENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "RUNNABLE-ENTITY-ARGUMENT":
+                entity.addArgument(self.getRunnableEntityArgument(child_element))
+            else:
+                raise NotImplementedError("Unsupported Arguments of runnable entity <%s>" % tag_name)
+
+    def readRunnableEntity(self, element: ET.Element, entity: RunnableEntity):
+        self.readExecutableEntity(element, entity)
+        self.readRunnableEntityArguments(element, entity)
+
+        entity.setCanBeInvokedConcurrently(self.getChildElementOptionalBooleanValue(element, "CAN-BE-INVOKED-CONCURRENTLY"))
+        entity.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
+
+        self.readDataReceivePointByArguments(element, entity)
+        self.readDataReceivePointByValues(element, entity)
+        self.readDataReadAccesses(element, entity)
+        self.readDataWriteAccesses(element, entity)
+        self.readDataSendPoints(element, entity)
+        self.readInternalBehaviorServerCallPoint(element, entity)
+        self.readInternalTriggeringPoints(element, entity)
+        self.readModeAccessPoints(element, entity)
+        self.readModeSwitchPoints(element, entity)
+        self.readParameterAccesses(element, entity)
+        self.readReadLocalVariables(element, entity)
+        self.readWrittenLocalVariables(element, entity)
+
     def readSwcInternalBehaviorRunnables(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:RUNNABLES/xmlns:RUNNABLE-ENTITY", self.nsmap):
+        for child_element in self.findall(element, "RUNNABLES/RUNNABLE-ENTITY"):
             short_name = self.getShortName(child_element)
             entity = parent.createRunnableEntity(short_name)
             self.logger.debug("readRunnableEntities %s" % short_name)
             
-            self.readExecutableEntity(child_element, entity)
-            entity.can_be_invoked_concurrently = self.getChildElementOptionalBooleanValue(child_element, "CAN-BE-INVOKED-CONCURRENTLY")
-            entity.symbol = self.getChildElementOptionalLiteral(child_element, "SYMBOL")
-
-            self.readDataReceivePointByArguments(child_element, entity)
-            self.readDataReceivePointByValues(child_element, entity)
-            self.readDataReadAccesses(child_element, entity)
-            self.readDataWriteAccesses(child_element, entity)
-            self.readDataSendPoints(child_element, entity)
-            self.readParameterAccesses(child_element, entity)
-            self.readWrittenLocalVariables(child_element, entity)
-            self.readReadLocalVariables(child_element, entity)
-            self.readInternalBehaviorServerCallPoint(child_element, entity)
-            self.readInternalTriggeringPoint(child_element, entity)
+            self.readRunnableEntity(child_element, entity)
 
     def getRModeInAtomicSwcInstanceRef(self, element: ET.Element) -> RModeInAtomicSwcInstanceRef:
         iref = RModeInAtomicSwcInstanceRef()
-        iref.base_ref = self.getChildElementOptionalRefType(element, "BASE")
-        iref.context_port_ref = self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")
-        iref.context_mode_declaration_group_prototype_ref = self.getChildElementOptionalRefType(element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")
-        iref.target_mode_declaration_ref = self.getChildElementOptionalRefType(element, "TARGET-MODE-DECLARATION-REF")
+        iref.setBaseRef(self.getChildElementOptionalRefType(element, "BASE-REF")) \
+            .setContextPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")) \
+            .setContextModeDeclarationGroupPrototypeRef(self.getChildElementOptionalRefType(element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")) \
+            .setTargetModeDeclarationRef(self.getChildElementOptionalRefType(element, "TARGET-MODE-DECLARATION-REF"))
         return iref
 
     def readRTEEvent(self, element: ET.Element, event: RTEEvent):
@@ -669,38 +792,41 @@ class ARXMLParser(AbstractARXMLParser):
         event = parent.createOperationInvokedEvent(short_name)
         self.readOperationIRef(element, event)
         self.readRTEEvent(element, event)
-    
+
+    def readVariableDataPrototype(self, element: ET.Element, prototype: VariableDataPrototype):
+        self.readAutosarDataPrototype(element, prototype)
+        prototype.setInitValue(self.getInitValue(element))
+        
     def readExplicitInterRunnableVariables(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in element.findall("./xmlns:EXPLICIT-INTER-RUNNABLE-VARIABLES/xmlns:VARIABLE-DATA-PROTOTYPE", self.nsmap):
             short_name = self.getShortName(child_element)
             prototype = parent.createExplicitInterRunnableVariable(short_name)
-            prototype.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
-            prototype.type_tref = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
-            prototype.init_value = self.getInitValue(child_element)
+            self.readVariableDataPrototype(child_element, prototype)
 
     def readPerInstanceMemories(self, element: ET.Element, behavior: SwcInternalBehavior):
         for child_element in element.findall("./xmlns:PER-INSTANCE-MEMORYS/xmlns:PER-INSTANCE-MEMORY", self.nsmap):
             short_name = self.getShortName(child_element)
             memory = behavior.createPerInstanceMemory(short_name)
             self.readIdentifiable(child_element, memory)
-            memory.init_value = self.getChildElementOptionalLiteral(child_element, "INIT-VALUE")
-            memory.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
-            memory.type = self.getChildElementOptionalLiteral(child_element, "TYPE")
-            memory.type_definition = self.getChildElementOptionalLiteral(child_element, "TYPE-DEFINITION")
+            memory.setInitValue(self.getChildElementOptionalLiteral(child_element, "INIT-VALUE")) \
+                  .setSwDataDefProps(self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")) \
+                  .setType(self.getChildElementOptionalLiteral(child_element, "TYPE")) \
+                  .setTypeDefinition(self.getChildElementOptionalLiteral(child_element, "TYPE-DEFINITION"))
 
     def readAutosarDataPrototype(self, element: ET.Element, prototype: AutosarDataPrototype):
-        prototype.type_tref = self.getChildElementOptionalRefType(element, "TYPE-TREF")
+        self.readDataPrototype(element, prototype)
+        prototype.setTypeTRef(self.getChildElementOptionalRefType(element, "TYPE-TREF"))
 
-    def readParameterDataPrototype(self, element: ET.Element, behavior: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        prototype = behavior.createParameterDataPrototype(short_name)
+    def readParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
         self.readIdentifiable(element, prototype)
         self.readAutosarDataPrototype(element, prototype)
-        prototype.init_value = self.getInitValue(element)
+        prototype.setInitValue(self.getInitValue(element))
         
-    def readPerInstanceParameter(self, element: ET.Element, behavior: SwcInternalBehavior):
+    def readPerInstanceParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
         for child_element in element.findall("./xmlns:PER-INSTANCE-PARAMETERS/xmlns:PARAMETER-DATA-PROTOTYPE", self.nsmap):
-            self.readParameterDataPrototype(child_element, behavior)
+            short_name = self.getShortName(child_element)
+            prototype = behavior.createPerInstanceParameter(short_name)
+            self.readParameterDataPrototype(child_element, prototype)
 
     def readPortDefinedArgumentValue(self, element: ET.Element) -> PortDefinedArgumentValue:
         argument_value = PortDefinedArgumentValue()
@@ -720,12 +846,6 @@ class ARXMLParser(AbstractARXMLParser):
                 option.addPortArgValue(self.readPortDefinedArgumentValue(argument_value_tag))
             behavior.addPortAPIOption(option)
             
-    def readInitEvents(self, element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:INIT-EVENT", self.nsmap):
-            short_name = self.getShortName(child_element)
-            event = parent.createInitEvent(short_name)
-            self.readRTEEvent(child_element, event)
-
     def readTimingEvent(self, element: ET.Element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
         event = parent.createTimingEvent(short_name)
@@ -752,6 +872,11 @@ class ARXMLParser(AbstractARXMLParser):
         self.readRTEEvent(element, event)
         event.event_source_ref = self.getChildElementRefType(parent.short_name, element, "EVENT-SOURCE-REF")
 
+    def readInitEvent(self, element, parent: SwcInternalBehavior):
+        short_name = self.getShortName(element)
+        event = parent.createInitEvent(short_name)
+        self.readRTEEvent(element, event)
+
     def readSwcInternalBehaviorEvents(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in element.findall("./xmlns:EVENTS/*", self.nsmap):
             tag_name = self.getTagName(child_element.tag)
@@ -765,25 +890,59 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readDataReceivedEvent(child_element, parent)
             elif tag_name == "INTERNAL-TRIGGER-OCCURRED-EVENT":
                 self.readInternalTriggerOccurredEvent(child_element, parent)
+            elif tag_name == "INIT-EVENT":
+                self.readInitEvent(child_element, parent)
             else:
                 self._raiseError("Unsupported SwcInternalBehavior Event <%s>" % tag_name)
 
     def readSwPointerTargetProps(self, element: ET.Element, parent: SwDataDefProps):
-        child_element = element.find("./xmlns:SW-POINTER-TARGET-PROPS", self.nsmap)
-        if (child_element is not None):
+        child_element = self.find(element, "SW-POINTER-TARGET-PROPS")
+        if child_element is not None:
             sw_pointer_target_props = SwPointerTargetProps()
             sw_pointer_target_props.target_category = self.getChildElementOptionalLiteral(child_element, "TARGET-CATEGORY")
             sw_pointer_target_props.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
-            parent.sw_pointer_target_props = sw_pointer_target_props
+            parent.swPointerTargetProps = sw_pointer_target_props
+
+    def readLParagraph(self, element: ET.Element, paragraph: MultiLanguageParagraph):
+        for child_element in self.findall(element, "./L-1"):
+            l1 = LOverviewParagraph()
+            self.readElementAttributes(child_element, l1)
+            l1.value = child_element.text
+            if 'L' in child_element.attrib:
+                l1.l = child_element.attrib['L']
+            paragraph.addL1(l1)
+    
+    def getMultiLanguageParagraphs(self, element: ET.Element, key: str) -> List[MultiLanguageParagraph]:
+        paragraphs = []
+        for child_element in self.findall(element, key):
+            paragraph = MultiLanguageParagraph()
+            self.readElementAttributes(child_element, paragraph)
+            self.readLParagraph(child_element, paragraph)
+            paragraphs.append(paragraph)
+        return paragraphs
+
+    def getDocumentationBlock(self, element: ET.Element, key: str) -> DocumentationBlock:
+        block = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            block = DocumentationBlock()
+            self.readElementAttributes(child_element, block)
+            for paragraph in self.getMultiLanguageParagraphs(child_element, "P"):
+                block.addP(paragraph)
+        return block
 
     def readGeneralAnnotation(self, element: ET.Element, annotation: GeneralAnnotation):
-        annotation.label = self.getMultilanguageLongName(element, "LABEL")
+        annotation.setAnnotationOrigin(self.getChildElementOptionalLiteral(element, 'ANNOTATION-ORIGIN')) \
+            .setAnnotationText(self.getDocumentationBlock(element, "ANNOTATION-TEXT")) \
+            .setLabel(self.getMultilanguageLongName(element, "LABEL"))
 
-    def readAnnotations(self, element: ET.Element, props: SwDataDefProps) :
+    def getAnnotations(self, element: ET.Element) -> List[Annotation]:
+        annotations = []
         for child_element in element.findall("./xmlns:ANNOTATIONS/xmlns:ANNOTATION", self.nsmap):
             annotation = Annotation()
             self.readGeneralAnnotation(child_element, annotation)
-            props.addAnnotation(annotation)
+            annotations.append(annotation)
+        return annotations
 
     def getSwAxisIndividual(self, element: ET.Element) -> SwAxisIndividual:
         props = SwAxisIndividual()
@@ -820,6 +979,11 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "SW-CALPRM-AXIS":
                 set.addSwCalprmAxis(self.getSwCalprmAxis(child_element))
         return set
+    
+    def readSwDataDefProsInvalidValue(self, element: ET.Element, props: SwDataDefProps):
+        child_element = self.find(element, "INVALID-VALUE/*")
+        if child_element is not None:
+            props.setInvalidValue(self.getValueSpecification(child_element))
 
     def getSwDataDefProps(self, element: ET.Element, key: str) -> SwDataDefProps:
         child_element = element.find("./xmlns:%s" % key, self.nsmap)
@@ -830,30 +994,36 @@ class ARXMLParser(AbstractARXMLParser):
                 sw_data_def_props = SwDataDefProps()
                 self.readElementAttributes(child_element, sw_data_def_props)
 
-                self.readAnnotations(conditional_tag, sw_data_def_props)
-                sw_data_def_props.baseTypeRef = self.getChildElementOptionalRefType(conditional_tag, "BASE-TYPE-REF")
-                sw_data_def_props.dataConstrRef = self.getChildElementOptionalRefType(conditional_tag, "DATA-CONSTR-REF")
-                sw_data_def_props.compuMethodRef = self.getChildElementOptionalRefType(conditional_tag, "COMPU-METHOD-REF")
-                sw_data_def_props.swImplPolicy = self.getChildElementOptionalLiteral(conditional_tag, "SW-IMPL-POLICY")
-                sw_data_def_props.implementationDataTypeRef = self.getChildElementOptionalRefType(conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF")
-                sw_data_def_props.swCalibrationAccess = self.getChildElementOptionalLiteral(conditional_tag, "SW-CALIBRATION-ACCESS")
-                sw_data_def_props.swCalprmAxisSet = self.getSwCalprmAxisSet(conditional_tag, "SW-CALPRM-AXIS-SET")
-                sw_data_def_props.swRecordLayoutRef = self.getChildElementOptionalRefType(conditional_tag, "SW-RECORD-LAYOUT-REF")
-                sw_data_def_props.valueAxisDataTypeRef = self.getChildElementOptionalRefType(conditional_tag, "VALUE-AXIS-DATA-TYPE-REF")
-                sw_data_def_props.setUnitRef(self.getChildElementOptionalRefType(conditional_tag, "UNIT-REF"))
+                for annotation in self.getAnnotations(conditional_tag):
+                    sw_data_def_props.addAnnotation(annotation)
+
+                sw_data_def_props.setBaseTypeRef(self.getChildElementOptionalRefType(conditional_tag, "BASE-TYPE-REF")) \
+                                 .setDataConstrRef(self.getChildElementOptionalRefType(conditional_tag, "DATA-CONSTR-REF")) \
+                                 .setCompuMethodRef(self.getChildElementOptionalRefType(conditional_tag, "COMPU-METHOD-REF")) \
+                                 .setSwImplPolicy(self.getChildElementOptionalLiteral(conditional_tag, "SW-IMPL-POLICY")) \
+                                 .setImplementationDataTypeRef(self.getChildElementOptionalRefType(conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF")) \
+                                 .setSwCalibrationAccess(self.getChildElementOptionalLiteral(conditional_tag, "SW-CALIBRATION-ACCESS")) \
+                                 .setSwCalprmAxisSet(self.getSwCalprmAxisSet(conditional_tag, "SW-CALPRM-AXIS-SET")) \
+                                 .setSwRecordLayoutRef(self.getChildElementOptionalRefType(conditional_tag, "SW-RECORD-LAYOUT-REF")) \
+                                 .setValueAxisDataTypeRef(self.getChildElementOptionalRefType(conditional_tag, "VALUE-AXIS-DATA-TYPE-REF")) \
+                                 .setUnitRef(self.getChildElementOptionalRefType(conditional_tag, "UNIT-REF"))
+                self.readSwDataDefProsInvalidValue(conditional_tag, sw_data_def_props)
                 self.readSwPointerTargetProps(conditional_tag, sw_data_def_props)
                 self.readElementAttributes(conditional_tag, sw_data_def_props.conditional)
         return sw_data_def_props
+    
+    def readAutosarDataType(self, element: ET.Element, data_type: AutosarDataType):
+        self.readIdentifiable(element, data_type)
+        data_type.setSwDataDefProps(self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS"))
 
     def readApplicationPrimitiveDataType(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         data_type = parent.createApplicationPrimitiveDataType(short_name)
         self.logger.debug("readApplicationPrimitiveDataTypes %s" % short_name)
-        self.readIdentifiable(element, data_type)
-        data_type.sw_data_def_props = self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS")
+        self.readAutosarDataType(element, data_type)
 
     def readApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
-        prototype.typeTRef = self.getChildElementOptionalRefType(element, "TYPE-TREF")
+        prototype.setTypeTRef(self.getChildElementOptionalRefType(element, "TYPE-TREF"))
 
     def readApplicationRecordElements(self, element: ET.Element, parent: ApplicationRecordDataType):
         for child_element in element.findall("./xmlns:ELEMENTS/xmlns:APPLICATION-RECORD-ELEMENT", self.nsmap):
@@ -868,7 +1038,7 @@ class ARXMLParser(AbstractARXMLParser):
         data_type = parent.createApplicationRecordDataType(short_name)
         self.logger.debug("readApplicationRecordDataTypes %s" % short_name)
         self.readIdentifiable(element, data_type)
-        data_type.sw_data_def_props = self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS")
+        data_type.setSwDataDefProps(self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS"))
         self.readApplicationRecordElements(element, data_type)
 
     def readImplementationDataTypeElements(self, element: ET.Element, parent: ImplementationDataType):
@@ -876,10 +1046,10 @@ class ARXMLParser(AbstractARXMLParser):
             short_name = self.getShortName(child_element)
             type_element = parent.createImplementationDataTypeElement(short_name)   # type: ImplementationDataTypeElement
             self.readIdentifiable(child_element, type_element)
-            type_element.arraySize = self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE")
-            type_element.array_size_semantics = self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS")
+            type_element.setArraySize(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE")) \
+                        .setArraySizeSemantics(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS"))
             self.readImplementationDataTypeElements(child_element, type_element)
-            type_element.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
+            type_element.swDataDefProps = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
 
     def readImplementationDataType(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -892,7 +1062,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self._raiseError("Array Sub-Element of <%s> do not defined." % data_type.short_name)
             array_sub_element = data_type.getImplementationDataTypeElements()[0]
             if (array_sub_element.category == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
-                data_type.setArrayElementType(array_sub_element.sw_data_def_props.implementationDataTypeRef.value)
+                data_type.setArrayElementType(array_sub_element.swDataDefProps.implementationDataTypeRef.value)
             elif (array_sub_element.category == ImplementationDataType.CATEGORY_TYPE_VALUE):  # TODO: fix 
                 return
             else:
@@ -930,10 +1100,10 @@ class ARXMLParser(AbstractARXMLParser):
         self.readElementAttributes(element, com_spec)
         for child_element in element.findall("./xmlns:COMPOSITE-NETWORK-REPRESENTATIONS/xmlns:COMPOSITE-NETWORK-REPRESENTATION", self.nsmap):
             com_spec.addCompositeNetworkRepresentation(self.getCompositeNetworkRepresentation(child_element))
-        com_spec.data_element_ref = self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")
-        com_spec.network_representation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
-        com_spec.handle_out_of_range = self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE")
-        com_spec.uses_end_to_end_protection = self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION")
+        com_spec.dataElementRef = self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")
+        com_spec.networkRepresentation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
+        com_spec.handleOutOfRange = self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE")
+        com_spec.usesEndToEndProtection = self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION")
 
     def getSwValues(self, element: ET.Element, key: str) -> SwValues:
         child_element = element.find("./xmlns:%s" % key, self.nsmap) # type: ET.Element
@@ -977,7 +1147,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getInitValue(self, element: ET.Element) -> ValueSpecification:
         value_spec = None
-        child_element = element.find("./xmlns:INIT-VALUE/*", self.nsmap)
+        child_element = self.find(element, "INIT-VALUE/*")
         if child_element is not None:
             self.logger.debug("getInitValue")
             value_spec = self.getValueSpecification(child_element)
@@ -986,25 +1156,31 @@ class ARXMLParser(AbstractARXMLParser):
     def getClientComSpec(self, element: ET.Element) -> ClientComSpec:
         com_spec = ClientComSpec()
         self.readElementAttributes(element, com_spec)
-        com_spec.operation_ref = self.getChildElementOptionalRefType(element, "OPERATION-REF")
+        com_spec.operationRef = self.getChildElementOptionalRefType(element, "OPERATION-REF")
         return com_spec
     
     def getQueuedReceiverComSpec(self, element: ET.Element) -> QueuedReceiverComSpec:
         com_spec = QueuedReceiverComSpec()
         self.readElementAttributes(element, com_spec)
         self.readReceiverComSpec(element, com_spec)
-        com_spec.queue_length = self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH")
+        com_spec.queueLength = self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH")
+        return com_spec
+    
+    def getModeSwitchReceiverComSpec(self, element: ET.Element) -> ModeSwitchReceiverComSpec:
+        com_spec = ModeSwitchReceiverComSpec()
+        self.readElementAttributes(element, com_spec)
+        com_spec.modeGroupRef = self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")
         return com_spec
 
     def getNonqueuedReceiverComSpec(self, element: ET.Element) -> NonqueuedReceiverComSpec:
         com_spec = NonqueuedReceiverComSpec()
         self.readElementAttributes(element, com_spec)            
         self.readReceiverComSpec(element, com_spec)
-        com_spec.alive_timeout = self.getChildElementOptionalFloatValue(element, "ALIVE-TIMEOUT")
-        com_spec.enable_updated = self.getChildElementOptionalBooleanValue(element, "ENABLE-UPDATE")
-        com_spec.handle_never_received = self.getChildElementOptionalBooleanValue(element, "HANDLE-NEVER-RECEIVED")
-        com_spec.handel_timeout_type = self.getChildElementOptionalLiteral(element, "HANDLE-TIMEOUT-TYPE")
-        com_spec.init_value = self.getInitValue(element)
+        com_spec.aliveTimeout = self.getChildElementOptionalFloatValue(element, "ALIVE-TIMEOUT")
+        com_spec.enableUpdated = self.getChildElementOptionalBooleanValue(element, "ENABLE-UPDATE")
+        com_spec.handleNeverReceived = self.getChildElementOptionalBooleanValue(element, "HANDLE-NEVER-RECEIVED")
+        com_spec.handleTimeoutType = self.getChildElementOptionalLiteral(element, "HANDLE-TIMEOUT-TYPE")
+        com_spec.initValue = self.getInitValue(element)
         return com_spec
 
     def readRequiredComSpec(self, element: ET.Element, parent: RPortPrototype):
@@ -1016,18 +1192,29 @@ class ARXMLParser(AbstractARXMLParser):
                 parent.addRequiredComSpec(self.getClientComSpec(child_element))
             elif tag_name == "QUEUED-RECEIVER-COM-SPEC":
                 parent.addRequiredComSpec(self.getQueuedReceiverComSpec(child_element))
+            elif tag_name == "MODE-SWITCH-RECEIVER-COM-SPEC":
+                parent.addRequiredComSpec(self.getModeSwitchReceiverComSpec(child_element))
             else:
                 self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
     def readRPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
-        for child_element in element.findall("./xmlns:PORTS/xmlns:R-PORT-PROTOTYPE", self.nsmap):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readRPortPrototype %s" % short_name)
-            prototype = parent.createRPortPrototype(short_name)
-            self.readIdentifiable(child_element, prototype)
-            prototype.required_interface_tref = self.getChildElementOptionalRefType(child_element, "REQUIRED-INTERFACE-TREF")
+        short_name = self.getShortName(element)
+        self.logger.debug("readRPortPrototype %s" % short_name)
+        prototype = parent.createRPortPrototype(short_name)
+        self.readIdentifiable(element, prototype)
+        prototype.required_interface_tref = self.getChildElementOptionalRefType(element, "REQUIRED-INTERFACE-TREF")
 
-            self.readRequiredComSpec(child_element, prototype)
+        self.readRequiredComSpec(element, prototype)
+
+    def readAtomicSwComponentTypePorts(self, element: ET.Element, sw_component: AtomicSwComponentType):
+        for child_element in element.findall("./xmlns:PORTS/*", self.nsmap):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "P-PORT-PROTOTYPE":
+                self.readPPortPrototype(child_element, sw_component)
+            elif tag_name == "R-PORT-PROTOTYPE":
+                self.readRPortPrototype(child_element, sw_component)
+            else:
+                self._raiseError("Unsupported Port Prototype <%s>" % tag_name)
 
     def readTransmissionAcknowledgementRequest(self, element: ET.Element) -> TransmissionAcknowledgementRequest:
         child_element = element.find("./xmlns:TRANSMISSION-ACKNOWLEDGE", self.nsmap)
@@ -1042,23 +1229,33 @@ class ARXMLParser(AbstractARXMLParser):
         self.readElementAttributes(element, com_spec)
         for child_element in element.findall("./xmlns:COMPOSITE-NETWORK-REPRESENTATIONS/xmlns:COMPOSITE-NETWORK-REPRESENTATION", self.nsmap):
             com_spec.addCompositeNetworkRepresentation(self.getCompositeNetworkRepresentation(child_element))
-        com_spec.data_element_ref = self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")
-        com_spec.network_representation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
-        com_spec.handle_out_of_range = self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE")
-        com_spec.transmission_acknowledge = self.readTransmissionAcknowledgementRequest(element)
-        com_spec.uses_end_to_end_protection = self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION")
+        com_spec.setDataElementRef(self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")) \
+                .setNetworkRepresentation(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")) \
+                .setHandleOutOfRange(self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE")) \
+                .setTransmissionAcknowledge(self.readTransmissionAcknowledgementRequest(element)) \
+                .setUsesEndToEndProtection(self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION"))
 
     def getNonqueuedSenderComSpec(self, element) -> NonqueuedSenderComSpec:
         com_spec = NonqueuedSenderComSpec()
         self.readSenderComSpec(element, com_spec)
-        com_spec.init_value = self.getInitValue(element)
+        com_spec.setInitValue(self.getInitValue(element))
         return com_spec
     
     def getServerComSpec(self, element) -> ServerComSpec:
         com_spec = ServerComSpec()
+        com_spec.setOperationRef(self.getChildElementOptionalRefType(element, "OPERATION-REF")) \
+                .setQueueLength(self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH"))
+        return com_spec
+    
+    def getQueuedSenderComSpec(self, element) -> QueuedSenderComSpec:
+        com_spec = QueuedSenderComSpec()
         self.readSenderComSpec(element, com_spec)
-        com_spec.operation_ref = self.getChildElementOptionalRefType(element, "OPERATION-REF")
-        com_spec.queue_length = self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH")
+        return com_spec
+    
+    def getModeSwitchSenderComSpec(self, element) -> ModeSwitchSenderComSpec:
+        com_spec = ModeSwitchSenderComSpec()
+        com_spec.setModeGroupRef(self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")) \
+                .setQueueLength(self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH"))
         return com_spec
 
     def readProvidedComSpec(self, element: ET.Element, parent: PPortPrototype):
@@ -1068,18 +1265,21 @@ class ARXMLParser(AbstractARXMLParser):
                 parent.addProvidedComSpec(self.getNonqueuedSenderComSpec(child_element))
             elif tag_name == "SERVER-COM-SPEC":
                 parent.addProvidedComSpec(self.getServerComSpec(child_element))
+            elif tag_name == "QUEUED-SENDER-COM-SPEC":
+                parent.addProvidedComSpec(self.getQueuedSenderComSpec(child_element))
+            elif tag_name == "MODE-SWITCH-SENDER-COM-SPEC":
+                parent.addProvidedComSpec(self.getModeSwitchSenderComSpec(child_element))
             else:
-                raise NotImplementedError("Unsupported RequiredComSpec <%s>" % tag_name)
+                self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
     def readPPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
-        for child_element in element.findall("./xmlns:PORTS/xmlns:P-PORT-PROTOTYPE", self.nsmap):
-            short_name = self.getShortName(child_element)
-            self.logger.debug("readPPortPrototype %s" % short_name)
-            prototype = parent.createPPortPrototype(short_name)
-            self.readIdentifiable(child_element, prototype)
-            prototype.provided_interface_tref = self.getChildElementOptionalRefType(child_element, "PROVIDED-INTERFACE-TREF")
+        short_name = self.getShortName(element)
+        self.logger.debug("readPPortPrototype %s" % short_name)
+        prototype = parent.createPPortPrototype(short_name)
+        self.readIdentifiable(element, prototype)
+        prototype.provided_interface_tref = self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF")
 
-            self.readProvidedComSpec(child_element, prototype)
+        self.readProvidedComSpec(element, prototype)
 
     def readPortGroupInnerGroupIRefs(self, element: ET.Element, parent: PortGroup):
         for child_element in element.findall("./xmlns:INNER-GROUP-IREFS/xmlns:INNER-GROUP-IREF", self.nsmap):
@@ -1110,8 +1310,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readSwComponentType(self, element: ET.Element, parent: SwComponentType):
         self.readIdentifiable(element, parent)
-        self.readRPortPrototype(element, parent)
-        self.readPPortPrototype(element, parent)
+        self.readAtomicSwComponentTypePorts(element, parent)
         self.readSwComponentTypePortGroups(element, parent)
 
     def readAtomicSwComponentType(self, element, parent: AtomicSwComponentType):
@@ -1239,7 +1438,7 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = element.find("./xmlns:DATA-TYPE-MAPPING-REFS", self.nsmap)
         self.logger.debug("readDataTypeMappingSet")
         if child_element is not None:
-            for ref in self.getChildElementRefTypeList(child_element, "DATA-TYPE-MAPPING-REF"):
+            for ref in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-MAPPING-REF"):
                 parent.addDataTypeMapping(ref)
 
     def readCompositionSwComponentType(self, element: ET.Element, parent: ARPackage):
@@ -1269,6 +1468,7 @@ class ARXMLParser(AbstractARXMLParser):
     def readModeRequestTypeMaps(self, element: ET.Element, parent: DataTypeMappingSet):
         for child_element in element.findall("./xmlns:MODE-REQUEST-TYPE-MAPS/xmlns:MODE-REQUEST-TYPE-MAP", self.nsmap):
             map = ModeRequestTypeMap()
+            self.readElementAttributes(child_element, map)
             map.implementation_data_type_ref = self.getChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
             map.mode_group_ref = self.getChildElementOptionalRefType(child_element, "MODE-GROUP-REF")
             parent.addModeRequestTypeMap(map)
@@ -1280,40 +1480,51 @@ class ARXMLParser(AbstractARXMLParser):
         self.readDataTypeMaps(element, mapping_set)
         self.readModeRequestTypeMaps(element, mapping_set)
 
-    def readDataElements(self, element: ET.Element, parent: SenderReceiverInterface):
+    def readSenderReceiverInterfaceDataElements(self, element: ET.Element, sr_interface: SenderReceiverInterface):
         for child_element in element.findall("./xmlns:DATA-ELEMENTS/xmlns:VARIABLE-DATA-PROTOTYPE", self.nsmap):
             short_name = self.getShortName(child_element)
-            prototype = parent.createDataElement(short_name)
+            prototype = sr_interface.createDataElement(short_name)
             self.readIdentifiable(child_element, prototype)
-            prototype.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
+            prototype.swDataDefProps = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
             self.readAutosarDataPrototype(child_element, prototype)
-            prototype.init_value = self.getInitValue(child_element)
+            prototype.initValue = self.getInitValue(child_element)
+
+    def readSenderReceiverInterfaceInvalidationPolicies(self, element: ET.Element, sr_interface: SenderReceiverInterface):
+        for child_element in self.findall(element, "INVALIDATION-POLICYS/INVALIDATION-POLICY"):
+            policy = InvalidationPolicy()
+            policy.setDataElementRef(self.getChildElementOptionalRefType(child_element, "DATA-ELEMENT-REF")) \
+                  .setHandleInvalid(self.getChildElementOptionalLiteral(child_element, "HANDLE-INVALID"))
+            sr_interface.addInvalidationPolicy(policy)
 
     def readSenderReceiverInterfaces(self, element, parent: ARPackage):
         short_name = self.getShortName(element)
         sr_interface = parent.createSenderReceiverInterface(short_name)
         self.readIdentifiable(element, sr_interface)
-        sr_interface.is_service = self.getChildElementOptionalBooleanValue(element, "IS-SERVICE")
-        self.readDataElements(element, sr_interface)
+        sr_interface.isService = self.getChildElementOptionalBooleanValue(element, "IS-SERVICE")
+        self.readSenderReceiverInterfaceDataElements(element, sr_interface)
+        self.readSenderReceiverInterfaceInvalidationPolicies(element, sr_interface)
 
     def readArgumentDataPrototypes(self, element: ET.Element, parent: ClientServerOperation):
         for child_element in element.findall("./xmlns:ARGUMENTS/xmlns:ARGUMENT-DATA-PROTOTYPE", self.nsmap):
             short_name = self.getShortName(child_element)
             prototype = ArgumentDataPrototype(property, short_name)
-            prototype.type_tref = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
+            self.readIdentifiable(child_element, prototype)
+            prototype.swDataDefProps = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
+            prototype.typeTRef = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
             prototype.direction = self.getChildElementOptionalLiteral(child_element, "DIRECTION")
             parent.addArgumentDataPrototype(prototype)
 
     def readPossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
         child_element = element.find("./xmlns:POSSIBLE-ERROR-REFS", self.nsmap)
         if child_element is not None:
-            for ref in self.getChildElementRefTypeList(child_element, "POSSIBLE-ERROR-REF"):
+            for ref in self.getChildElementRefTypeList(child_element, "./POSSIBLE-ERROR-REF"):
                 parent.addPossibleErrorRef(ref)
 
     def readOperations(self, element: ET.Element, parent: ClientServerInterface):
         for child_element in element.findall("./xmlns:OPERATIONS/xmlns:CLIENT-SERVER-OPERATION", self.nsmap):
             short_name = self.getShortName(child_element)
             operation = parent.createOperation(short_name)
+            self.readIdentifiable(child_element, operation)
             self.readArgumentDataPrototypes(child_element, operation)
             self.readPossibleErrorRefs(child_element, operation)
 
@@ -1324,12 +1535,13 @@ class ARXMLParser(AbstractARXMLParser):
             error.error_code = self.getChildElementOptionalNumericalValue(child_element, "ERROR-CODE")
 
     def readPortInterface(self, element: ET.Element, port_interface: PortInterface):
-        port_interface.is_service = self.getChildElementOptionalBooleanValue(element, "IS-SERVICE")
+        port_interface.isService = self.getChildElementOptionalBooleanValue(element, "IS-SERVICE")
         port_interface.serviceKind = self.getChildElementOptionalLiteral(element, "SERVICE-KIND")
 
     def readClientServerInterface(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         cs_interface = parent.createClientServerInterface(short_name)
+        self.readIdentifiable(element, cs_interface)
         self.readPortInterface(element, cs_interface)
         self.readOperations(element, cs_interface)
         self.readPossibleErrors(element, cs_interface)
@@ -1440,14 +1652,14 @@ class ARXMLParser(AbstractARXMLParser):
         self.readValueSpecification(element, value_spec)
         child_elements = element.findall("./xmlns:ELEMENTS/*", self.nsmap)
         for child_element in child_elements:
-            value_spec.add_element(self.getValueSpecification(child_element))
+            value_spec.addElement(self.getValueSpecification(child_element))
         return value_spec
 
     def getConstantReference(self, element: ET.Element) -> ConstantReference:
         self.logger.debug("getConstantReference")
         value_spec = ConstantReference()
         self.readValueSpecification(element, value_spec)
-        value_spec.constant_ref = self.getChildElementOptionalRefType(element, "CONSTANT-REF")
+        value_spec.setConstantRef(self.getChildElementOptionalRefType(element, "CONSTANT-REF"))
         return value_spec         
 
     def getValueSpecification(self, element: ET.Element) -> ValueSpecification:
@@ -1470,7 +1682,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readRecordValueSpecificationFields(self, element: ET.Element, spec: RecordValueSpecification):
         for child_element in element.findall("./xmlns:FIELDS/*", self.nsmap):
-            spec.add_field(self.getValueSpecification(child_element))
+            spec.addField(self.getValueSpecification(child_element))
 
     def getRecordValueSpecification(self, element: ET.Element) -> RecordValueSpecification:
         value_spec = RecordValueSpecification()
@@ -1483,8 +1695,8 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("readConstantSpecification %s" % short_name)
         spec = parent.createConstantSpecification(short_name)
         self.readIdentifiable(element, spec)
-        for value_spec_tag in element.findall("./xmlns:VALUE-SPEC/*", self.nsmap):
-            spec.value_spec = self.getValueSpecification(value_spec_tag)
+        for value_spec_tag in self.findall(element, "VALUE-SPEC/*"):
+            spec.setValueSpec(self.getValueSpecification(value_spec_tag))
                 
     def readInternalConstrs(self, element: ET.Element, parent: DataConstrRule):
         child_element = element.find("./xmlns:INTERNAL-CONSTRS", self.nsmap)
@@ -1527,7 +1739,11 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("readUnit %s" % short_name)
         unit = parent.createUnit(short_name)
         self.readIdentifiable(element, unit)
-        unit.display_name = self.getChildElementOptionalLiteral(element, "DISPLAY-NAME")
+        unit.setDisplayName(self.getChildElementOptionalLiteral(element, "DISPLAY-NAME")) \
+            .setFactorSiToUnit(self.getChildElementOptionalFloatValue(element, "FACTOR-SI-TO-UNIT")) \
+            .setOffsetSiToUnit(self.getChildElementOptionalFloatValue(element, "OFFSET-SI-TO-UNIT")) \
+            .setPhysicalDimensionRef(self.getChildElementOptionalRefType(element, "PHYSICAL-DIMENSION-REF"))
+
 
     def readEndToEndDescriptionDataId(self, element: ET.Element, parent: EndToEndDescription):
         child_element = element.find("./xmlns:DATA-IDS", self.nsmap)
@@ -1549,11 +1765,13 @@ class ARXMLParser(AbstractARXMLParser):
         return desc
     
     def getVariableDataPrototypeInSystemInstanceRef(self, element: ET.Element) -> VariableDataPrototypeInSystemInstanceRef:
-        iref = VariableDataPrototypeInSystemInstanceRef()
-        iref.contextComponentRef = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
-        iref.contextCompositionRef = self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF")
-        iref.contextPortRef = self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")
-        iref.targetDataPrototypeRef = self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF")
+        iref = None
+        if element is not None:
+            iref = VariableDataPrototypeInSystemInstanceRef()
+            iref.context_component_refs = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
+            iref.context_composition_ref = self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF")
+            iref.context_port_ref = self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")
+            iref.target_data_prototype_ref = self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF")
         return iref
     
     def getEndToEndProtectionVariablePrototype(self, element: ET.Element) -> EndToEndProtectionVariablePrototype:
@@ -1595,7 +1813,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readAutosarDataType(self, element: ET.Element, data_type: AutosarDataType):
         self.readIdentifiable(element, data_type)
-        data_type.sw_data_def_props = self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS")
+        data_type.swDataDefProps = self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS")
 
     def readApplicationDataType(self, element: ET.Element, data_type: ApplicationDataType):
         self.readAutosarDataType(element, data_type)
@@ -1709,6 +1927,638 @@ class ARXMLParser(AbstractARXMLParser):
         self.readPortInterface(element, mode_interface)
         self.readModeSwitchInterfaceModeGroup(element, mode_interface)
 
+    def readEOCExecutableEntityRef(self, element: ET.Element, constraint: ExecutionOrderConstraint):
+        short_name = self.getShortName(element)
+        self.logger.debug("readEocExecutableEntityRef %s" % short_name)
+        entity_ref = constraint.createEOCExecutableEntityRef(short_name)
+        self.readIdentifiable(element, entity_ref)
+        for ref in self.getChildElementRefTypeList(element, "SUCCESSOR-REFS/SUCCESSOR-REF"):
+            entity_ref.addSuccessorRef(ref)
+
+    def readExecutionOrderConstraintOrderedElement(self, element: ET.Element, constrain: ExecutionOrderConstraint):
+        for child_element in self.findall(element, "ORDERED-ELEMENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "EOC-EXECUTABLE-ENTITY-REF":
+                self.readEOCExecutableEntityRef(child_element, constrain)
+            else:
+                self._raiseError("Unsupported order element <%s>." % tag_name)
+
+    def readExecutionOrderConstraint(self, element: ET.Element, extension: TimingExtension):
+        short_name = self.getShortName(element)
+        self.logger.debug("readExecutionOrderConstraint %s" % short_name)
+        constraint = extension.createExecutionOrderConstraint(short_name)
+        self.readIdentifiable(element, constraint)
+        self.readExecutionOrderConstraintOrderedElement(element, constraint)
+
+    def readTimingExtension(self, element: ET.Element, extension: TimingExtension):
+        for child_element in self.findall(element, "TIMING-REQUIREMENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "EXECUTION-ORDER-CONSTRAINT":
+                self.readExecutionOrderConstraint(child_element, extension)
+            else:
+                self._raiseError("Unsupported timing requirement <%s>" % tag_name)
+
+    def readSwcTiming(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readSwcTiming %s" % short_name)
+        timing = parent.createSwcTiming(short_name)
+        self.readIdentifiable(element, timing)
+        self.readTimingExtension(element, timing)
+
+    def readFrameTriggering(self, element: ET.Element, triggering: FrameTriggering):
+        for ref in self.getChildElementRefTypeList(element, 'FRAME-PORT-REFS/FRAME-PORT-REF'):
+            triggering.addFramePortRef(ref)
+        triggering.setFrameRef(self.getChildElementOptionalRefType(element, "FRAME-REF"))
+        for child_element in self.findall(element, 'PDU-TRIGGERINGS/PDU-TRIGGERING-REF-CONDITIONAL'):
+            triggering.addPduTriggeringRef(self.getChildElementOptionalRefType(child_element, "PDU-TRIGGERING-REF"))
+
+    def readCanFrameTriggering(self, element: ET.Element, triggering: CanFrameTriggering):
+        self.logger.debug("Read CanFrameTriggering %s" % triggering.getShortName())
+        self.readIdentifiable(element, triggering)
+        self.readFrameTriggering(element, triggering)
+        triggering.setCanAddressingMode(self.getChildElementOptionalLiteral(element, "CAN-ADDRESSING-MODE")) \
+                  .setCanFdFrameSupport(self.getChildElementOptionalBooleanValue(element, "CAN-FD-FRAME-SUPPORT")) \
+                  .setCanFrameRxBehavior(self.getChildElementOptionalLiteral(element, "CAN-FRAME-RX-BEHAVIOR")) \
+                  .setCanFrameTxBehavior(self.getChildElementOptionalLiteral(element, "CAN-FRAME-TX-BEHAVIOR")) \
+                  .setIdentifier(self.getChildElementOptionalNumericalValue(element, "IDENTIFIER")) \
+                  .setRxIdentifierRange(self.getChildElementRxIdentifierRange(element, "RX-IDENTIFIER-RANGE"))
+
+
+    def readLinFrameTriggering(self, element: ET.Element, triggering: LinFrameTriggering):
+        self.logger.debug("Read LinFrameTriggering %s" % triggering.getShortName())
+        self.readIdentifiable(element, triggering)
+        self.readFrameTriggering(element, triggering)
+        triggering.setIdentifier(self.getChildElementOptionalNumericalValue(element, "IDENTIFIER")) \
+                  .setLinChecksum(self.getChildElementOptionalLiteral(element, "LIN-CHECKSUM"))
+
+    def readISignalTriggering(self, element: ET.Element, triggering: ISignalTriggering):
+        self.logger.debug("Read ISignalTriggering %s" % triggering.getShortName())
+        self.readIdentifiable(element, triggering)
+        triggering.setISignalGroupRef(self.getChildElementOptionalRefType(element, "I-SIGNAL-GROUP-REF"))
+        for ref in self.getChildElementRefTypeList(element, 'I-SIGNAL-PORT-REFS/I-SIGNAL-PORT-REF'):
+            triggering.addISignalPortRef(ref)
+        triggering.setISignalRef(self.getChildElementOptionalRefType(element, "I-SIGNAL-REF"))
+
+    def readPduTriggering(self, element: ET.Element, triggering: PduTriggering):
+        self.logger.debug("Read PduTriggering %s" % triggering.getShortName())
+        self.readIdentifiable(element, triggering)
+        for ref in self.getChildElementRefTypeList(element, 'I-PDU-PORT-REFS/I-PDU-PORT-REF'):
+            triggering.addIPduPortRef(ref)
+        triggering.setIPduRef(self.getChildElementOptionalRefType(element, "I-PDU-REF"))
+        for child_element in self.findall(element, 'I-SIGNAL-TRIGGERINGS/I-SIGNAL-TRIGGERING-REF-CONDITIONAL'):
+            triggering.addISignalTriggeringRef(self.getChildElementOptionalRefType(child_element, "I-SIGNAL-TRIGGERING-REF"))
+
+    def readPhysicalChannel(self, element: ET.Element, channel: PhysicalChannel):
+        for child_element in self.findall(element, 'COMM-CONNECTORS/COMMUNICATION-CONNECTOR-REF-CONDITIONAL'):
+            channel.addCommConnectorRef(self.getChildElementOptionalRefType(child_element, "COMMUNICATION-CONNECTOR-REF"))
+        
+        for child_element in self.findall(element, "FRAME-TRIGGERINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-FRAME-TRIGGERING":
+                triggering = channel.createCanFrameTriggering(self.getShortName(child_element))
+                self.readCanFrameTriggering(child_element, triggering)
+            elif tag_name == "LIN-FRAME-TRIGGERING":
+                triggering = channel.createLinFrameTriggering(self.getShortName(child_element))
+                self.readLinFrameTriggering(child_element, triggering)
+            else:
+                raise NotImplementedError("Unsupported Frame Triggering <%s>" % tag_name)
+            
+        for child_element in self.findall(element, "I-SIGNAL-TRIGGERINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "I-SIGNAL-TRIGGERING":
+                triggering = channel.createISignalTriggering(self.getShortName(child_element))
+                self.readISignalTriggering(child_element, triggering)
+            else:
+                raise NotImplementedError("Unsupported Frame Triggering <%s>" % tag_name)
+            
+        for child_element in self.findall(element, "PDU-TRIGGERINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "PDU-TRIGGERING":
+                triggering = channel.createPduTriggering(self.getShortName(child_element))
+                self.readPduTriggering(child_element, triggering)
+            else:
+                raise NotImplementedError("Unsupported Frame Triggering <%s>" % tag_name)
+
+    def readCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
+        self.readIdentifiable(element, channel)
+        self.readPhysicalChannel(element, channel)
+
+    def readLinPhysicalChannel(self, element: ET.Element, channel: LinPhysicalChannel):
+        self.readIdentifiable(element, channel)
+        self.readPhysicalChannel(element, channel)
+
+    def readCommunicationClusterPhysicalChannels(self, element: ET.Element, cluster: CommunicationCluster):
+        for child_element in self.findall(element, "PHYSICAL-CHANNELS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-PHYSICAL-CHANNEL":
+                channel = cluster.createCanPhysicalChannel(self.getShortName(child_element))
+                self.readCanPhysicalChannel(child_element, channel)
+            elif tag_name == "LIN-PHYSICAL-CHANNEL":
+                channel = cluster.createLinPhysicalChannel(self.getShortName(child_element))
+                self.readLinPhysicalChannel(child_element, channel)
+            else:
+                raise NotImplementedError("Unsupported Physical Channel <%s>" % tag_name)
+
+
+    def readCommunicationCluster(self, element: ET.Element, cluster: CommunicationCluster):
+        cluster.setBaudrate(self.getChildElementOptionalNumericalValue(element, "BAUDRATE")) 
+        self.readCommunicationClusterPhysicalChannels(element, cluster)
+        cluster.setProtocolName(self.getChildElementOptionalLiteral(element, "PROTOCOL-NAME")) \
+               .setProtocolVersion(self.getChildElementOptionalLiteral(element, "PROTOCOL-VERSION"))
+
+    def readAbstractCanCluster(self, element: ET.Element, cluster: AbstractCanCluster):
+        cluster.setCanFdBaudrate(self.getChildElementOptionalNumericalValue(element, "CAN-FD-BAUDRATE")) 
+
+    def readLinCluster(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readLinCluster %s" % short_name)
+        cluster = parent.createLinCluster(short_name)
+        self.readIdentifiable(element, cluster)
+        child_element = self.find(element, "LIN-CLUSTER-VARIANTS/LIN-CLUSTER-CONDITIONAL")
+        if child_element is not None:
+            self.readCommunicationCluster(child_element, cluster)
+
+    def readCanCluster(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readCanCluster %s" % short_name)
+        cluster = parent.createCanCluster(short_name)
+        self.readIdentifiable(element, cluster)
+        child_element = self.find(element, "CAN-CLUSTER-VARIANTS/CAN-CLUSTER-CONDITIONAL")
+        if child_element is not None:
+            self.readCommunicationCluster(child_element, cluster)
+            self.readAbstractCanCluster(child_element, cluster)
+
+    def readPduToFrameMappings(self, element: ET.Element, parent: Frame):
+        for child_element in self.findall(element, "PDU-TO-FRAME-MAPPINGS/PDU-TO-FRAME-MAPPING"):
+            short_name = self.getShortName(child_element)
+            self.logger.debug("readPduToFrameMapping %s" % short_name)
+            mapping = parent.createPduToFrameMapping(short_name)
+            self.readIdentifiable(child_element, mapping)
+            mapping.packingByteOrder = self.getChildElementOptionalLiteral(child_element, "PACKING-BYTE-ORDER")
+            mapping.pduRef = self.getChildElementOptionalRefType(child_element, "PDU-REF")
+            mapping.startPosition = self.getChildElementOptionalNumericalValue(child_element, "START-POSITION")
+
+    def readFrame(self, element: ET.Element, frame: Frame):
+        self.readIdentifiable(element, frame)
+        frame.frameLength = self.getChildElementOptionalNumericalValue(element, "FRAME-LENGTH")
+        self.readPduToFrameMappings(element, frame)
+
+    def readLinUnconditionalFrame(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("LinUnconditionalFrame %s" % short_name)
+        frame = parent.createLinUnconditionalFrame(short_name)
+        self.readFrame(element, frame)
+
+    def readNmPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readNmPdu %s" % short_name)
+        pdu = parent.createNmPdu(short_name)
+        self.readIdentifiable(element, pdu)
+        self.readIPdu(element, pdu)
+
+    def readNPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readNPdu %s" % short_name)
+        pdu = parent.createNPdu(short_name)
+        self.readIdentifiable(element, pdu)
+        self.readIPdu(element, pdu)
+
+    def readIPdu(self, element: ET.Element, pdu: IPdu):
+        pdu.setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH"))
+        
+    def readDcmIPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readDcmIPdu %s" % short_name)
+        pdu = parent.createDcmIPdu(short_name)
+        self.readIdentifiable(element, pdu)
+        self.readIPdu(element, pdu)
+        pdu.setDiagPduType(self.getChildElementOptionalLiteral(element, "DIAG-PDU-TYPE"))
+
+    def readSecuredIPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readSecuredIPdu %s" % short_name)
+        pdu = parent.createSecuredIPdu(short_name)
+        self.readIdentifiable(element, pdu)
+        self.readIPdu(element, pdu)
+
+    def readNmNode(self, element: ET.Element, nm_node: NmNode):
+        nm_node.setControllerRef(self.getChildElementOptionalRefType(element, "CONTROLLER-REF")) \
+            .setNmIfEcuRef(self.getChildElementOptionalRefType(element, "NM-IF-ECU-REF")) \
+            .setNmNodeId(self.getChildElementOptionalNumericalValue(element, "NM-NODE-ID"))
+        for ref in self.getChildElementRefTypeList(element, "RX-NM-PDU-REFS/RX-NM-PDU-REF"):
+            nm_node.addRxNmPduRef(ref)
+        for ref in self.getChildElementRefTypeList(element, "TX-NM-PDU-REFS/TX-NM-PDU-REF"):
+            nm_node.addTxNmPduRefs(ref)
+
+    def readCanNmNode(self, element: ET.Element, parent: NmCluster):
+        short_name = self.getShortName(element)
+        self.logger.debug("readCanNmNode %s" % short_name)
+        nm_node = parent.createCanNmNode(short_name)            # type: CanNmNode
+        self.readIdentifiable(element, nm_node)
+        self.readNmNode(element, nm_node)
+
+        nm_node.setNmMsgCycleOffset(self.getChildElementOptionalFloatValue(element, "NM-MSG-CYCLE-OFFSET")) \
+               .setNmMsgReducedTime(self.getChildElementOptionalFloatValue(element, "NM-MSG-REDUCED-TIME")) \
+               .setNmRangeConfig(self.getChildElementRxIdentifierRange(element, "NM-RANGE-CONFIG"))
+
+    def readNmClusterNmNodes(self, element: ET.Element, parent: NmCluster):
+        self.logger.debug("readNmConfigNmNodes %s" % parent.short_name)
+        for child_element in self.findall(element, "NM-NODES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-NM-NODE":
+                self.readCanNmNode(child_element, parent)
+            else:
+                self._raiseError("Unsupported Nm Node <%s>" % tag_name)
+
+    def getCanNmClusterCoupling(self, element: ET.Element) -> CanNmClusterCoupling:
+        coupling  = CanNmClusterCoupling()
+        
+        for ref in self.getChildElementRefTypeList(element, "COUPLED-CLUSTER-REFS/COUPLED-CLUSTER-REF"):
+            coupling.addCoupledClusterRef(ref)
+
+        coupling.setNmBusloadReductionEnabled(self.getChildElementOptionalBooleanValue(element, "NM-BUSLOAD-REDUCTION-ENABLED")) \
+                .setNmImmediateRestartEnabled(self.getChildElementOptionalBooleanValue(element, "NM-IMMEDIATE-RESTART-ENABLED"))
+    
+        return coupling
+
+    def readNmConfigNmClusterCouplings(self, element: ET.Element, nm_config: NmConfig):
+        self.logger.debug("readNmClusterNmClusterCouplings %s" % nm_config.getShortName())
+        for child_element in self.findall(element, "NM-CLUSTER-COUPLINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-NM-CLUSTER-COUPLING":
+                nm_config.addNmClusterCouplings(self.getCanNmClusterCoupling(child_element))
+            else:
+                self._raiseError("Unsupported Nm Node <%s>" % tag_name)
+
+    def readNmCluster(self, element: ET.Element, cluster: NmCluster):
+        cluster.setCommunicationClusterRef(self.getChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF")) \
+               .setNmChannelId(self.getChildElementOptionalNumericalValue(element, "NM-CHANNEL-ID")) \
+               .setNmChannelSleepMaster(self.getChildElementOptionalBooleanValue(element, "NM-CHANNEL-SLEEP-MASTER"))
+        self.readNmClusterNmNodes(element, cluster)
+        cluster.setNmSynchronizingNetwork(self.getChildElementOptionalBooleanValue(element, "NM-SYNCHRONIZING-NETWORK"))
+
+    def readCanNmCluster(self, element: ET.Element, parent: NmConfig):
+        short_name = self.getShortName(element)
+        self.logger.debug("readCanNmCluster %s" % short_name)
+        cluster = parent.createCanNmCluster(short_name)         # type: CanNmCluster
+        self.readIdentifiable(element, cluster)
+        self.readNmCluster(element, cluster)
+
+        cluster.setNmBusloadReductionActive(self.getChildElementOptionalBooleanValue(element, "NM-BUSLOAD-REDUCTION-ACTIVE")) \
+               .setNmCarWakeUpRxEnabled(self.getChildElementOptionalBooleanValue(element, "NM-CAR-WAKE-UP-RX-ENABLED")) \
+               .setNmCbvPosition(self.getChildElementOptionalNumericalValue(element, "NM-CBV-POSITION")) \
+               .setNmChannelActive(self.getChildElementOptionalBooleanValue(element, "NM-CHANNEL-ACTIVE")) \
+               .setNmImmediateNmCycleTime(self.getChildElementOptionalFloatValue(element, "NM-IMMEDIATE-NM-CYCLE-TIME")) \
+               .setNmImmediateNmTransmissions(self. getChildElementOptionalNumericalValue(element, "NM-IMMEDIATE-NM-TRANSMISSIONS")) \
+               .setNmMessageTimeoutTime(self.getChildElementOptionalFloatValue(element, "NM-MESSAGE-TIMEOUT-TIME")) \
+               .setNmMsgCycleTime(self.getChildElementOptionalFloatValue(element, "NM-MSG-CYCLE-TIME")) \
+               .setNmNetworkTimeout(self.getChildElementOptionalFloatValue(element, "NM-NETWORK-TIMEOUT")) \
+               .setNmNidPosition(self. getChildElementOptionalNumericalValue(element, "NM-NID-POSITION")) \
+               .setNmRemoteSleepIndicationTime(self.getChildElementOptionalFloatValue(element, "NM-REMOTE-SLEEP-INDICATION-TIME")) \
+               .setNmRepeatMessageTime(self.getChildElementOptionalFloatValue(element, "NM-REPEAT-MESSAGE-TIME")) \
+               .setNmUserDataLength(self. getChildElementOptionalNumericalValue(element, "NM-USER-DATA-LENGTH")) \
+               .setNmWaitBusSleepTime(self.getChildElementOptionalFloatValue(element, "NM-WAIT-BUS-SLEEP-TIME"))
+        
+    def readNmConfigNmClusters(self, element: ET.Element, parent: NmConfig):
+        for child_element in self.findall(element, "NM-CLUSTERS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-NM-CLUSTER":
+                self.readCanNmCluster(child_element, parent)
+            else:
+                self._raiseError("Unsupported Nm Cluster <%s>" % tag_name)
+    
+    def readNmConfig(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("NmConfig %s" % short_name)
+        config = parent.createNmConfig(short_name)                  # type: NmConfig
+        self.readIdentifiable(element, config)
+        self.readNmConfigNmClusters(element, config)
+        self.readNmConfigNmClusterCouplings(element, config)
+
+    def readCanTpConfig(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("CanTpConfig %s" % short_name)
+        pdu = parent.createCanTpConfig(short_name)
+        self.readIdentifiable(element, pdu)
+
+    def readCanFrame(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("CanFrame %s" % short_name)
+        frame = parent.createCanFrame(short_name)
+        self.readFrame(element, frame)
+
+    def readEcuInstance(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("EcuInstance %s" % short_name)
+        instance = parent.createEcuInstance(short_name)
+        self.readIdentifiable(element, instance)
+
+    '''
+    def getFrameMappings(self, element: ET.Element) -> List[FrameMapping]:
+        mappings = []
+        for child_element in self.findall(element, 'FRAME-MAPPINGS/'):
+            mapping = FrameMapping()
+            mapping.sourceFrameRef = self.getChildElementOptionalRefType(child_element, "SOURCE-FRAME-REF")
+            mapping.targetFrameRef = self.getChildElementOptionalRefType(child_element, "TARGET-FRAME-REF")
+            mappings.append(mapping)
+        return mappings
+    '''
+
+    def getISignalMappings(self, element: ET.Element) -> List[ISignalMapping]:
+        mappings = []
+        for child_element in self.findall(element, "SIGNAL-MAPPINGS/I-SIGNAL-MAPPING"):
+            mapping = ISignalMapping()
+            mapping.sourceSignalRef = self.getChildElementOptionalRefType(child_element, "SOURCE-SIGNAL-REF")
+            mapping.targetSignalRef = self.getChildElementOptionalRefType(child_element, "TARGET-SIGNAL-REF")
+            mappings.append(mapping)
+        return mappings
+    
+    '''
+    def getIPduMappings(self, element: ET.Element) -> List[IPduMapping]:
+        mappings = []
+        for child_element in self.findall(element, tag_name):
+            mapping = IPduMapping()
+            mapping.sourceIPduRef = self.getChildElementOptionalRefType(child_element, "SOURCE-IPDU-REF")
+            mapping.targetIPduRef = self.getChildElementOptionalRefType(child_element, "TARGET-IPDU-REF")
+            mappings.append(mapping)
+        return mappings
+    '''
+
+    def readGateway(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Gateway %s" % short_name)
+        gateway = parent.createGateway(short_name)
+        self.readIdentifiable(element, gateway)
+        gateway.ecuRef = self.getChildElementOptionalRefType(element, "ECU-REF")
+        for mapping in self.getISignalMappings(element):
+            gateway.addSignalMapping(mapping)
+
+    def readISignal(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("ISignal %s" % short_name)
+        signal = parent.createISignal(short_name)
+        self.readIdentifiable(element, signal)
+        signal.dataTypePolicy = self.getChildElementOptionalLiteral(element, "DATA-TYPE-POLICY")
+        signal.initValue = self.getInitValue(element)
+        signal.length = self.getChildElementOptionalNumericalValue(element, "LENGTH")
+        signal.networkRepresentationProps = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION-PROPS")
+        signal.systemSignalRef = self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-REF")
+
+    def readEcucValueCollectionEcucValues(self, element: ET.Element, parent: EcucValueCollection):
+        for child_element in self.findall(element, "ECUC-VALUES/ECUC-MODULE-CONFIGURATION-VALUES-REF-CONDITIONAL"):
+            ref = self.getChildElementOptionalRefType(child_element, "ECUC-MODULE-CONFIGURATION-VALUES-REF") 
+            if (ref is not None):
+                parent.addEcucValueRef(ref)
+            self.logger.debug("EcucValue <%s> of EcucValueCollection <%s> has been added", ref.value, parent.short_name)
+
+    def readEcucValueCollection(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("EcucValueCollection %s" % short_name)
+        collection = parent.createEcucValueCollection(short_name)
+        self.readIdentifiable(element, collection)
+        collection.setEcuExtractRef(self.getChildElementOptionalRefType(element, "ECU-EXTRACT-REF"))
+        self.readEcucValueCollectionEcucValues(element, collection)
+
+    def readEcucParameterValue(self, element: ET.Element, param_value: EcucParameterValue):
+        param_value.setDefinitionRef(self.getChildElementOptionalRefType(element, "DEFINITION-REF"))
+        for annotation in self.getAnnotations(element):
+            param_value.addAnnotation(annotation)
+
+    def getEcucTextualParamValue(self, element: ET.Element) -> EcucTextualParamValue:
+        param_value = EcucTextualParamValue()
+        self.readEcucParameterValue(element, param_value)
+        param_value.setValue(self.getChildElementOptionalLiteral(element, "VALUE"))
+        return param_value
+
+    def getEcucNumericalParamValue(self, element: ET.Element) -> EcucNumericalParamValue:
+        param_value = EcucNumericalParamValue()
+        self.readEcucParameterValue(element, param_value)
+        param_value.setValue(self.getChildElementOptionalNumericalValue(element, "VALUE"))
+        return param_value
+
+    def readEcucContainerValueParameterValues(self, element: ET.Element, container_value: EcucContainerValue):
+        for child_element in self.findall(element, "PARAMETER-VALUES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-TEXTUAL-PARAM-VALUE":
+                container_value.addParameterValue(self.getEcucTextualParamValue(child_element))
+            elif tag_name == "ECUC-NUMERICAL-PARAM-VALUE":
+                container_value.addParameterValue(self.getEcucNumericalParamValue(child_element))
+            else:
+                raise NotImplementedError("Unsupported EcucParameterValue <%s>" % tag_name)
+            
+    def readEcucAbstractReferenceValue(self, element: ET.Element, value: EcucAbstractReferenceValue):
+        value.setDefinitionRef(self.getChildElementOptionalRefType(element, "DEFINITION-REF"))
+        for annotation in self.getAnnotations(element):
+            value.addAnnotation(annotation)
+
+    def getEcucReferenceValue(self, element: ET.Element) -> EcucReferenceValue:
+        value = EcucReferenceValue()
+        self.readEcucAbstractReferenceValue(element, value)
+        value.setValueRef(self.getChildElementOptionalRefType(element, "VALUE-REF"))
+        return value
+    
+    def getAnyInstanceRef(self, element: ET.Element, key) -> AnyInstanceRef:
+        instance_ref = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            instance_ref = AnyInstanceRef()
+            instance_ref.setBaseRef(self.getChildElementOptionalRefType(child_element, "BASE-REF")) \
+                .setContextElementRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-ELEMENT-REF")) \
+                .setTargetRef(self.getChildElementOptionalRefType(child_element, "TARGET-REF"))
+        return instance_ref
+    
+    def getEcucInstanceReferenceValue(self, element: ET.Element) -> EcucInstanceReferenceValue:
+        value = EcucInstanceReferenceValue()
+        self.readEcucAbstractReferenceValue(element, value)
+        value.setValueIRef(self.getAnyInstanceRef(element, "VALUE-IREF"))
+        return value
+            
+    def readEcucContainerValueReferenceValues(self, element: ET.Element, container_value: EcucContainerValue):
+        for child_element in self.findall(element, "REFERENCE-VALUES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-REFERENCE-VALUE":
+                container_value.addReferenceValue(self.getEcucReferenceValue(child_element))
+            elif tag_name == "ECUC-INSTANCE-REFERENCE-VALUE":
+                container_value.addReferenceValue(self.getEcucInstanceReferenceValue(child_element))
+            else:
+                raise NotImplementedError("Unsupported EcucParameterValue <%s>" % tag_name)
+
+    def readEcucContainerValue(self, element: ET.Element, container_value: EcucContainerValue):
+        self.readIdentifiable(element, container_value)
+        container_value.setDefinitionRef(self.getChildElementOptionalRefType(element, "DEFINITION-REF"))
+        self.readEcucContainerValueParameterValues(element, container_value)
+        self.readEcucContainerValueReferenceValues(element, container_value)
+        self.readEcucContainerValueSubContainers(element, container_value)
+
+    def readEcucContainerValueEcucContainerValue(self, element: ET.Element, parent: EcucContainerValue):
+        short_name = self.getShortName(element)
+        self.logger.debug("EcucContainerValue %s" % short_name)
+        container_value = parent.createSubContainer(short_name)
+        self.readEcucContainerValue(element, container_value)
+
+    def readEcucContainerValueSubContainers(self, element: ET.Element, parent: EcucContainerValue):
+        for child_element in self.findall(element, "SUB-CONTAINERS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-CONTAINER-VALUE":
+                self.readEcucContainerValueEcucContainerValue(child_element, parent)
+            else:
+                raise NotImplementedError("Unsupported Sub Container %s" % tag_name) 
+
+    def readEcucModuleConfigurationValuesEcucContainerValue(self, element: ET.Element, parent: EcucModuleConfigurationValues):
+        short_name = self.getShortName(element)
+        self.logger.debug("EcucContainerValue %s" % short_name)
+        container_value = parent.createContainer(short_name)
+        self.readEcucContainerValue(element, container_value)
+
+    def readEcucModuleConfigurationValuesContainers(self, element: ET.Element, values: EcucModuleConfigurationValues):
+        for child_element in self.findall(element, "CONTAINERS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECUC-CONTAINER-VALUE":
+                self.readEcucModuleConfigurationValuesEcucContainerValue(child_element, values)
+            else:
+                raise NotImplementedError("Unsupported Container %s" % tag_name) 
+
+    def readEcucModuleConfigurationValues(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("EcucModuleConfigurationValues %s" % short_name)
+        values = parent.createEcucModuleConfigurationValues(short_name)
+        self.readIdentifiable(element, values)
+        values.setDefinitionRef(self.getChildElementOptionalRefType(element, "DEFINITION-REF"))
+        values.setImplementationConfigVariant(self.getChildElementOptionalLiteral(element, "IMPLEMENTATION-CONFIG-VARIANT"))
+        values.setModuleDescriptionRef(self.getChildElementOptionalRefType(element, "MODULE-DESCRIPTION-REF"))
+        self.readEcucModuleConfigurationValuesContainers(element, values)
+
+    def readPhysicalDimensions(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readPhysicalDimensions %s" % short_name)
+        dimension = parent.createPhysicalDimension(short_name)
+        self.readIdentifiable(element, dimension)
+        dimension.setCurrentExp(self.getChildElementOptionalNumericalValue(element, "CURRENT-EXP")) \
+                 .setLengthExp(self.getChildElementOptionalNumericalValue(element, "LENGTH-EXP")) \
+
+    '''
+    def getIPduMappings(self, element: ET.Element) -> List[IPduMapping]:
+        mappings = []
+        for child_element in self.findall(element, tag_name):
+            mapping = IPduMapping()
+            mapping.sourceIPduRef = self.getChildElementOptionalRefType(child_element, "SOURCE-IPDU-REF")
+            mapping.targetIPduRef = self.getChildElementOptionalRefType(child_element, "TARGET-IPDU-REF")
+            mappings.append(mapping)
+        return mappings
+    '''
+
+    def readISignalGroup(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("ISignalGroup %s" % short_name)
+        group = parent.createISignalGroup(short_name)
+        self.readIdentifiable(element, group)
+        for ref_type in self.getChildElementRefTypeList(element, "I-SIGNAL-REFS/I-SIGNAL-REF"):
+            group.addISignalRef(ref_type)
+        group.systemSignalGroupRef = self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-GROUP-REF")
+
+    def readSystemSignal(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("SystemSignal %s" % short_name)
+        signal = parent.createSystemSignal(short_name)
+        self.readIdentifiable(element, signal)
+        signal.setDynamicLength(self.getChildElementOptionalBooleanValue(element, "DYNAMIC-LENGTH"))
+
+    def readSystemSignalGroup(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("SystemSignalGroup %s" % short_name)
+        group = parent.createSystemSignalGroup(short_name)
+        self.readIdentifiable(element, group)
+        for ref_type in self.getChildElementRefTypeList(element, "SYSTEM-SIGNAL-REFS/SYSTEM-SIGNAL-REF"):
+            group.addSystemSignalRefs(ref_type)
+
+    def readISignalToPduMappings(self, element: ET.Element, parent: ISignalIPdu):
+        for child_element in self.findall(element, "I-SIGNAL-TO-PDU-MAPPINGS/I-SIGNAL-TO-I-PDU-MAPPING"):
+            short_name = self.getShortName(child_element)
+            mapping = parent.createISignalToPduMappings(short_name)
+            self.readIdentifiable(child_element, mapping)
+            mapping.setISignalRef(self.getChildElementOptionalRefType(child_element, "I-SIGNAL-REF")) \
+                   .setISignalGroupRef(self.getChildElementOptionalRefType(child_element, "I-SIGNAL-GROUP-REF")) \
+                   .setPackingByteOrder(self.getChildElementOptionalLiteral(child_element, "PACKING-BYTE-ORDER")) \
+                   .setStartPosition(self.getChildElementOptionalNumericalValue(child_element, "START-POSITION")) \
+                   .setTransferProperty(self.getChildElementOptionalLiteral(child_element, "TRANSFER-PROPERTY")) \
+                   .setUpdateIndicationBitPosition(self.getChildElementOptionalNumericalValue(child_element, "UPDATE-INDICATION-BIT-POSITION"))
+
+    def readISignalIPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("ISignalIPdu %s" % short_name)
+        i_pdu = parent.createISignalIPdu(short_name)
+        self.readIdentifiable(element, i_pdu)
+        i_pdu.setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH"))
+        self.readISignalToPduMappings(element, i_pdu)
+        i_pdu.setUnusedBitPattern(self.getChildElementOptionalLiteral(element, "UNUSED-BIT-PATTERN"))
+
+    def getISignalIPduRefs(self, element: ET.Element) -> List[RefType]:
+        ref_types = [] 
+        for child_element in self.findall(element, "I-SIGNAL-I-PDUS/I-SIGNAL-I-PDU-REF-CONDITIONAL"):
+            ref_types.append(self.getChildElementOptionalRefType(child_element, "I-SIGNAL-I-PDU-REF"))
+        return ref_types
+
+    def readISignalIPduGroup(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("ISignalIPduGroup %s" % short_name)
+        group = parent.createISignalIPduGroup(short_name)
+        self.readIdentifiable(element, group)
+        group.communicationDirection = self.getChildElementOptionalLiteral(element, "COMMUNICATION-DIRECTION")
+        group.communicationMode = self.getChildElementOptionalLiteral(element, "COMMUNICATION-MODE")
+        for ref_type in self.getChildElementRefTypeList(element, "CONTAINED-I-SIGNAL-I-PDU-GROUP-REFS/CONTAINED-I-SIGNAL-I-PDU-GROUP-REF"):
+            group.addContainedISignalIPduGroupRef(ref_type)
+        for ref_type in self.getISignalIPduRefs(element):
+            group.addISignalIPduRef(ref_type)
+
+    def getSenderReceiverToSignalMapping(self, element: ET.Element) -> SenderReceiverToSignalMapping:
+        mapping = SenderReceiverToSignalMapping()
+        mapping.setDataElementIRef(self.getVariableDataPrototypeInSystemInstanceRef(self.find(element, "DATA-ELEMENT-IREF")))
+        mapping.setSystemSignalRef(self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-REF"))
+        return mapping
+    
+    def getSenderReceiverToSignalGroupMapping(self, element: ET.Element) -> SenderReceiverToSignalGroupMapping:
+        mapping = SenderReceiverToSignalGroupMapping()
+        mapping.setDataElementIRef(self.getVariableDataPrototypeInSystemInstanceRef(self.find(element, "DATA-ELEMENT-IREF")))
+        mapping.setSignalGroupRef(self.getChildElementOptionalRefType(element, "SIGNAL-GROUP-REF"))
+        return mapping
+    
+    def readSystemMappingDataMappings(self, element: ET.Element, mapping: SystemMapping):
+        for child_element in self.findall(element, "DATA-MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SENDER-RECEIVER-TO-SIGNAL-MAPPING":
+                mapping.addDataMapping(self.getSenderReceiverToSignalMapping(child_element))
+            elif tag_name == "SENDER-RECEIVER-TO-SIGNAL-GROUP-MAPPING":
+                mapping.addDataMapping(self.getSenderReceiverToSignalGroupMapping(child_element))
+            else:
+                raise NotImplementedError("Unsupported Data Mapping %s" % tag_name)
+
+    def readSystemMapping(self, element: ET.Element, parent: System):
+        short_name = self.getShortName(element)
+        self.logger.debug("SystemMapping %s" % short_name)
+        mapping = parent.createSystemMapping(short_name)
+        self.readIdentifiable(element, mapping)
+        self.readSystemMappingDataMappings(element, mapping)
+
+    def readSystemMappings(self, element: ET.Element, system: System):
+        for child_element in self.findall(element, "MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SYSTEM-MAPPING":
+                self.readSystemMapping(child_element, system)
+            else:
+                raise NotImplementedError("Unsupported Mapping %s" % tag_name)
+
+    def readSystem(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("System %s" % short_name)
+        system = parent.createSystem(short_name)
+        self.readIdentifiable(element, system)
+
+        system.setEcuExtractVersion(self.getChildElementOptionalLiteral(element, "ECU-EXTRACT-VERSION"))
+        for child_element in self.findall(element, "FIBEX-ELEMENTS/FIBEX-ELEMENT-REF-CONDITIONAL"):
+            system.addFibexElementRef(self.getChildElementOptionalRefType(child_element, "FIBEX-ELEMENT-REF"))
+
+        self.readSystemMappings(element, system)
+
     def readARPackageElements(self, element: ET.Element, parent: ARPackage):
         for child_element in self.findall(element, "./ELEMENTS/*"):
             tag_name = self.getTagName(child_element.tag)
@@ -1770,34 +2620,58 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readModeDeclarationGroup(child_element, parent)
             elif tag_name == "MODE-SWITCH-INTERFACE":
                 self.readModeSwitchInterface(child_element, parent)
-            elif tag_name == "SYSTEM":
+            elif tag_name == "SWC-TIMING":
+                self.readSwcTiming(child_element, parent)
+            elif tag_name == "LIN-CLUSTER":
+                self.readLinCluster(child_element, parent)
+            elif tag_name == "LIN-UNCONDITIONAL-FRAME":
+                self.readLinUnconditionalFrame(child_element, parent)
+            elif tag_name == "NM-PDU":
+                self.readNmPdu(child_element, parent)
+            elif tag_name == "N-PDU":
+                self.readNPdu(child_element, parent)
+            elif tag_name == "DCM-I-PDU":
+                self.readDcmIPdu(child_element, parent)
+            elif tag_name == "SECURED-I-PDU":
+                self.readSecuredIPdu(child_element, parent)
+            elif tag_name == "NM-CONFIG":
+                self.readNmConfig(child_element, parent)
+            elif tag_name == "CAN-TP-CONFIG":
+                self.readCanTpConfig(child_element, parent)
+            elif tag_name == "LIN-TP-CONFIG":
                 pass
+            elif tag_name == "SYSTEM":
+                self.readSystem(child_element, parent)
             elif tag_name == "ECU-INSTANCE":
-                pass
+                self.readEcuInstance(child_element, parent)
             elif tag_name == "GATEWAY":
-                pass
+                self.readGateway(child_element, parent)
             elif tag_name == "I-SIGNAL-I-PDU-GROUP":
-                pass
+                self.readISignalIPduGroup(child_element, parent)
             elif tag_name == "CAN-CLUSTER":
-                pass
+                self.readCanCluster(child_element, parent)
             elif tag_name == "CAN-FRAME":
-                pass
+                self.readCanFrame(child_element, parent)
             elif tag_name == "I-SIGNAL":
-                pass
+                self.readISignal(child_element, parent)
             elif tag_name == "I-SIGNAL-GROUP":
-                pass
+                self.readISignalGroup(child_element, parent)
             elif tag_name == "I-SIGNAL-I-PDU":
-                pass
+                self.readISignalIPdu(child_element, parent)
             elif tag_name == "SYSTEM-SIGNAL":
-                pass
+                self.readSystemSignal(child_element, parent)
             elif tag_name == "SYSTEM-SIGNAL-GROUP":
-                pass
+                self.readSystemSignalGroup(child_element, parent)
+            elif tag_name == "ECUC-VALUE-COLLECTION":
+                self.readEcucValueCollection(child_element, parent)
+            elif tag_name == "ECUC-MODULE-CONFIGURATION-VALUES":
+                self.readEcucModuleConfigurationValues(child_element, parent)
+            elif tag_name == "PHYSICAL-DIMENSION":
+                self.readPhysicalDimensions(child_element, parent)
             else:
                 self._raiseError("Unsupported element type of ARPackage <%s>" % tag_name)
                 #pass
 
-    
-
     def readARPackages(self, element: ET.Element, parent: ARPackage):
         for child_element in element.findall("./xmlns:AR-PACKAGES/xmlns:AR-PACKAGE", self.nsmap):
             short_name = self.getShortName(child_element)
@@ -1811,7 +2685,7 @@ class ARXMLParser(AbstractARXMLParser):
 
 
     def load(self, filename, document: AUTOSAR):
-        self.logger.info("Load %s ..." % filename)
+        self.logger.info("Load %s ..." % os.path.realpath(filename))
 
         tree = ET.parse(filename)
         root = tree.getroot()