armodel 1.5.0__py3-none-any.whl → 1.6.1__py3-none-any.whl

armodel/parser/arxml_parser.py

@@ -1,17 +1,42 @@
 from typing import List
 import xml.etree.ElementTree as ET
-
-from armodel.models.fibex.fibex_4_multiplatform import FrameMapping, IPduMapping, ISignalMapping
-
-from ..models.fibex.fibex_core import Frame
+import os
+
+from ..models.ar_ref import RefType
+from ..models.m2.autosar_templates.common_structure.implementation import ImplementationProps
+from ..models.m2.autosar_templates.common_structure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference, NumericalValueSpecification, RecordValueSpecification, TextValueSpecification, ValueSpecification
+from ..models.m2.autosar_templates.generic_structure.abstract_structure import AnyInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.composition.instance_refs import POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.port_interface.instance_refs import ApplicationCompositeElementInPortInterfaceInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior.instance_refs_usage import AutosarParameterRef, AutosarVariableRef, VariableInAtomicSWCTypeInstanceRef
+from ..models.m2.autosar_templates.system_template.instance_refs import VariableDataPrototypeInSystemInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.components.instance_refs import InnerPortGroupInCompositionInstanceRef, PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
+from ..models.m2.autosar_templates.sw_component_template.swc_internal_behavior import RunnableEntityArgument
+from ..models.m2.autosar_templates.sw_component_template.components import PortGroup, SwComponentType, SymbolProps, PPortPrototype, RPortPrototype
+from ..models.m2.autosar_templates.sw_component_template.composition import AssemblySwConnector, CompositionSwComponentType, DelegationSwConnector
+
+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, ParameterRequireComSpec, 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.data_dictionary.data_def_properties import SwDataDefProps
+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.port_interface import ModeSwitchInterface, PortInterface
+from ..models.m2.autosar_templates.sw_component_template.port_interface import InvalidationPolicy, ModeSwitchInterface, ParameterInterface, 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
@@ -22,31 +47,23 @@ 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, RModeGroupInAtomicSWCInstanceRef, VariableDataPrototypeInSystemInstanceRef, VariableInAtomicSWCTypeInstanceRef, AutosarParameterRef
-from ..models.sw_component import AtomicSwComponentType, CompositionSwComponentType, ModeAccessPoint, PortAPIOption, PortDefinedArgumentValue, PortGroup, ServiceDependency, SwComponentType, SwcServiceDependency
-from ..models.data_prototype import ApplicationCompositeElementDataPrototype, AutosarDataPrototype, DataPrototype, ParameterDataPrototype
+from ..models.sw_component import AtomicSwComponentType, PortAPIOption, PortDefinedArgumentValue, ServiceDependency,  SwcServiceDependency
+from ..models.m2.autosar_templates.sw_component_template.data_type.data_prototypes 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 RPortPrototype, PPortPrototype
-from ..models import ReceiverComSpec, ClientComSpec, NonqueuedReceiverComSpec
-from ..models import SenderComSpec, NonqueuedSenderComSpec, ServerComSpec
+
+from ..models import ImplementationDataType,  SwPointerTargetProps, DataTypeMappingSet, DataTypeMap
 from ..models import SenderReceiverInterface, ClientServerInterface, ClientServerOperation, ArgumentDataPrototype
 from ..models import Identifiable, AdminData, Sdg, Sd
-from ..models import AssemblySwConnector, PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
-from ..models import DelegationSwConnector
 from ..models import CompuMethod, CompuScale, CompuScales, Compu, CompuConst, CompuConstTextContent, CompuScaleConstantContents, CompuScaleRationalFormula, CompuRationalCoeffs, CompuNominatorDenominator
 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
 
@@ -55,29 +72,31 @@ 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 self.findall(element, "./SD"):
             sd = Sd()
             if 'GID' in child_element.attrib:
-                sd.gid = child_element.attrib['GID']
-            sd.value = child_element.text
+                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.gid = element.attrib["GID"]
+            sdg.setGID(element.attrib["GID"])
         self.readSd(element, sdg)
-        child_element = self.find(element, "./SDG")
-        if child_element is not None:
-            sdg.sdg_contents_type = self.getSdg(child_element)
+        for child_element in self.findall(element, "SDG"):
+            sdg.addSdgContentsType(self.getSdg(child_element))
         return sdg
     
     def readSdgs(self, element: ET.Element, admin_data: AdminData):
@@ -90,16 +109,21 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug("readAdminData")
             admin_data = AdminData()
             self.readSdgs(child_element, admin_data)
-            identifiable.admin_data = 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):
@@ -137,24 +161,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()
-            self.readElementAttributes(child_element, autosar_variable_iref)
-            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):
@@ -164,25 +195,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)
 
@@ -215,16 +246,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"):
@@ -234,7 +264,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):
@@ -523,7 +553,7 @@ class ARXMLParser(AbstractARXMLParser):
             short_name = self.getShortName(child_element)
             memory_section = consumption.createMemorySection(short_name)
             self.readIdentifiable(child_element, memory_section)
-            memory_section.alignment = self.getChildElementOptionalLiteral(child_element, "ALIGNMENT")
+            memory_section.setAlignment(self.getChildElementOptionalLiteral(child_element, "ALIGNMENT"))
             self.readMemorySectionOptions(child_element, memory_section)
             memory_section.size = self.getChildElementOptionalNumericalValue(child_element, "SIZE")
             memory_section.swAddrMethodRef = self.getChildElementOptionalRefType(child_element, "SW-ADDRMETHOD-REF")
@@ -586,6 +616,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)
@@ -613,22 +648,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 = 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):
@@ -636,7 +671,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):
@@ -644,11 +679,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)
@@ -665,10 +700,10 @@ class ARXMLParser(AbstractARXMLParser):
 
     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 getRModeGroupInAtomicSWCInstanceRef(self, element: ET.Element) -> RModeGroupInAtomicSWCInstanceRef:
@@ -676,45 +711,72 @@ class ARXMLParser(AbstractARXMLParser):
         iref = None
         if child_element is not None:
             iref = RModeGroupInAtomicSWCInstanceRef()
-            iref.contextRPort = self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")
-            iref.targetModeGroup = self.getChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF")
+            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.modeGroupIRef = self.getRModeGroupInAtomicSWCInstanceRef(child_element)
+            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 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.canBeInvokedConcurrently = self.getChildElementOptionalBooleanValue(child_element, "CAN-BE-INVOKED-CONCURRENTLY")
-            entity.symbol = self.getChildElementOptionalLiteral(child_element, "SYMBOL")
-            entity.swAddrMethodRef = self.getChildElementOptionalRefType(child_element, "SW-ADDR-METHOD-REF")
-
-            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.readInternalTriggeringPoints(child_element, entity)
-            self.readModeAccessPoints(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):
@@ -736,32 +798,35 @@ 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, prototype: ParameterDataPrototype):
         self.readIdentifiable(element, prototype)
         self.readAutosarDataPrototype(element, prototype)
-        prototype.init_value = self.getInitValue(element)
+        prototype.setInitValue(self.getInitValue(element))
         
     def readPerInstanceParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
         for child_element in element.findall("./xmlns:PER-INSTANCE-PARAMETERS/xmlns:PARAMETER-DATA-PROTOTYPE", self.nsmap):
@@ -837,21 +902,53 @@ class ARXMLParser(AbstractARXMLParser):
                 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()
@@ -888,6 +985,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)
@@ -898,30 +1000,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):
@@ -936,7 +1044,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):
@@ -944,10 +1052,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)
@@ -955,16 +1063,26 @@ class ARXMLParser(AbstractARXMLParser):
         self.readAutosarDataType(element, data_type)
         self.readImplementationDataTypeElements(element, data_type)
         data_type.setTypeEmitter(self.getChildElementOptionalLiteral(element, "TYPE-EMITTER"))
-        if (data_type.category == ImplementationDataType.CATEGORY_ARRAY):
+        if (data_type.getCategory().getValue() == ImplementationDataType.CATEGORY_ARRAY):
             if (len(data_type.getImplementationDataTypeElements()) < 1):
                 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)
-            elif (array_sub_element.category == ImplementationDataType.CATEGORY_TYPE_VALUE):  # TODO: fix 
+            if (array_sub_element.category.getValue() == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
+                data_type.setArrayElementType(array_sub_element.swDataDefProps.implementationDataTypeRef.value)
+            elif (array_sub_element.category.getValue() == ImplementationDataType.CATEGORY_TYPE_VALUE):  # TODO: fix 
                 return
             else:
-                self._raiseError("The category <%s> of array sub-element <%s> does not support." % (array_sub_element.category, data_type.short_name))
+                self._raiseError("The category <%s> of array sub-element <%s> does not support." % (array_sub_element.category.value, data_type.short_name))
+        elif (data_type.getCategory().getValue() == ImplementationDataType.CATEGORY_TYPE_STRUCTURE):
+            if (len(data_type.getImplementationDataTypeElements()) < 1):
+                self._raiseError("Structure Sub-Element of <%s> do not defined." % data_type.short_name)
+            self.readImplementationDataTypeSymbolProps(element, data_type)
+            struct_sub_element = data_type.getImplementationDataTypeElements()[0]
+            if (struct_sub_element.getCategory().getValue() == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
+                data_type.setStructElementType(struct_sub_element.getSwDataDefProps().getImplementationDataTypeRef().getValue())
+            else:
+                self._raiseError("The category <%s> of structure sub-element <%s> does not support." % (struct_sub_element.category.value, data_type.short_name))
 
     def readBaseTypeDirectDefinition(self, element: ET.Element, definition: BaseTypeDirectDefinition):
         definition.base_type_size = self.getChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE")
@@ -983,8 +1101,8 @@ class ARXMLParser(AbstractARXMLParser):
         iref = None
         if child_element is not None:
             iref = ApplicationCompositeElementInPortInterfaceInstanceRef()
-            iref.root_data_prototype_ref = self.getChildElementOptionalRefType(child_element, "ROOT-DATA-PROTOTYPE-REF")
-            iref.target_data_prototype_ref = self.getChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF")
+            iref.setRootDataPrototypeRef(self.getChildElementOptionalRefType(child_element, "ROOT-DATA-PROTOTYPE-REF"))\
+                .setTargetDataPrototypeRef(self.getChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF"))
         return iref
 
     def getCompositeNetworkRepresentation(self, element: ET.Element) -> CompositeNetworkRepresentation:
@@ -994,14 +1112,14 @@ class ARXMLParser(AbstractARXMLParser):
         representation.network_representation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
         return representation
 
-    def readReceiverComSpec(self, element, com_spec: ReceiverComSpec):
+    def readReceiverComSpec(self, element: ET.Element, com_spec: ReceiverComSpec):
         self.readElementAttributes(element, com_spec)
-        for child_element in element.findall("./xmlns:COMPOSITE-NETWORK-REPRESENTATIONS/xmlns:COMPOSITE-NETWORK-REPRESENTATION", self.nsmap):
+        for child_element in self.findall(element, "COMPOSITE-NETWORK-REPRESENTATIONS/COMPOSITE-NETWORK-REPRESENTATION"):
             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
@@ -1045,7 +1163,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)
@@ -1057,11 +1175,18 @@ class ARXMLParser(AbstractARXMLParser):
         com_spec.operationRef = self.getChildElementOptionalRefType(element, "OPERATION-REF")
         return com_spec
     
+    def getParameterRequireComSpec(self, element: ET.Element) -> ParameterRequireComSpec:
+        com_spec = ParameterRequireComSpec()
+        self.readElementAttributes(element, com_spec)
+        com_spec.setInitValue(self.getInitValue(element)) \
+                .setParameterRef(self.getChildElementOptionalRefType(element, "PARAMETER-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:
@@ -1074,11 +1199,11 @@ class ARXMLParser(AbstractARXMLParser):
         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):
@@ -1092,6 +1217,8 @@ class ARXMLParser(AbstractARXMLParser):
                 parent.addRequiredComSpec(self.getQueuedReceiverComSpec(child_element))
             elif tag_name == "MODE-SWITCH-RECEIVER-COM-SPEC":
                 parent.addRequiredComSpec(self.getModeSwitchReceiverComSpec(child_element))
+            elif tag_name == "PARAMETER-REQUIRE-COM-SPEC":
+                parent.addRequiredComSpec(self.getParameterRequireComSpec(child_element))
             else:
                 self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
@@ -1100,12 +1227,12 @@ class ARXMLParser(AbstractARXMLParser):
         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")
+        prototype.setRequiredInterfaceTRef(self.getChildElementOptionalRefType(element, "REQUIRED-INTERFACE-TREF"))
 
         self.readRequiredComSpec(element, prototype)
 
     def readAtomicSwComponentTypePorts(self, element: ET.Element, sw_component: AtomicSwComponentType):
-        for child_element in element.findall("./xmlns:PORTS/*", self.nsmap):
+        for child_element in self.findall(element, "PORTS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "P-PORT-PROTOTYPE":
                 self.readPPortPrototype(child_element, sw_component)
@@ -1127,23 +1254,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):
@@ -1153,6 +1290,10 @@ 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:
                 self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
@@ -1161,19 +1302,19 @@ class ARXMLParser(AbstractARXMLParser):
         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")
+        prototype.setProvidedInterfaceTRef(self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF"))
 
         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):
+        for child_element in self.findall(element, "INNER-GROUP-IREFS/INNER-GROUP-IREF"):
             inner_group_iref = InnerPortGroupInCompositionInstanceRef()
-            inner_group_iref.contextRef = self.getChildElementOptionalRefType(child_element, "CONTEXT-REF")
-            inner_group_iref.targetRef = self.getChildElementOptionalRefType(child_element, "TARGET-REF")
+            #inner_group_iref.contextRef = self.getChildElementOptionalRefType(child_element, "CONTEXT-REF")
+            inner_group_iref.setTargetRef(self.getChildElementOptionalRefType(child_element, "TARGET-REF"))
             parent.addInnerGroupIRef(inner_group_iref)
 
     def readPortGroupOuterPortRefs(self, element: ET.Element, parent: PortGroup):
-        for child_element in element.findall("./xmlns:OUTER-PORTS/xmlns:PORT-PROTOTYPE-REF-CONDITIONAL", self.nsmap):
+        for child_element in self.findall(element, "OUTER-PORTS/PORT-PROTOTYPE-REF-CONDITIONAL"):
             parent.addOuterPortRef(self.getChildElementOptionalRefType(child_element, "PORT-PROTOTYPE-REF"))
 
     def readPortGroup(self, element: ET.Element, parent: SwComponentType):
@@ -1230,40 +1371,40 @@ class ARXMLParser(AbstractARXMLParser):
         self.readAtomicSwComponentType(element, sw_component)
 
     def readPPortInCompositionInstanceRef(self, element: ET.Element, p_port_in_composition_instance_ref: PPortInCompositionInstanceRef):
-        p_port_in_composition_instance_ref.context_component_ref = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
-        p_port_in_composition_instance_ref.target_p_port_ref = self.getChildElementOptionalRefType(element, "TARGET-P-PORT-REF")
+        p_port_in_composition_instance_ref.setContextComponentRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")) \
+                                          .setTargetPPortRef(self.getChildElementOptionalRefType(element, "TARGET-P-PORT-REF"))
         
         self.logger.debug("PPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
-                          % (p_port_in_composition_instance_ref.context_component_ref.dest, p_port_in_composition_instance_ref.context_component_ref.value))
+                          % (p_port_in_composition_instance_ref.getContextComponentRef().getDest(), p_port_in_composition_instance_ref.getContextComponentRef().getValue()))
         self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s" 
-                          % (p_port_in_composition_instance_ref.target_p_port_ref.dest, p_port_in_composition_instance_ref.target_p_port_ref.value))
+                          % (p_port_in_composition_instance_ref.getTargetPPortRef().getDest(), p_port_in_composition_instance_ref.getTargetPPortRef().getValue()))
 
     def readRPortInCompositionInstanceRef(self, element, r_port_in_composition_instance_ref: RPortInCompositionInstanceRef):
-        r_port_in_composition_instance_ref.context_component_ref = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
-        r_port_in_composition_instance_ref.target_r_port_ref = self.getChildElementOptionalRefType(element, "TARGET-R-PORT-REF")
+        r_port_in_composition_instance_ref.setContextComponentRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")) \
+                                          .setTargetRPortRef(self.getChildElementOptionalRefType(element, "TARGET-R-PORT-REF"))
 
         self.logger.debug("RPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
-                          % (r_port_in_composition_instance_ref.context_component_ref.dest, r_port_in_composition_instance_ref.context_component_ref.value))
+                          % (r_port_in_composition_instance_ref.getContextComponentRef().getDest(), r_port_in_composition_instance_ref.getContextComponentRef().getValue()))
         self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s" 
-                          % (r_port_in_composition_instance_ref.target_r_port_ref.dest, r_port_in_composition_instance_ref.target_r_port_ref.value))
+                          % (r_port_in_composition_instance_ref.getTargetRPortRef().getDest(), r_port_in_composition_instance_ref.getTargetRPortRef().getValue()))
 
     def readAssemblySwConnectorProviderIRef(self, element: ET.Element, parent: AssemblySwConnector):
-        child_element = element.find("./xmlns:PROVIDER-IREF", self.nsmap)
+        child_element = self.find(element, "PROVIDER-IREF")
         if (child_element is not None):
             provide_iref = PPortInCompositionInstanceRef()
             self.readElementAttributes(child_element, provide_iref)
             self.readPPortInCompositionInstanceRef(child_element, provide_iref)
-            parent.provider_iref = provide_iref
+            parent.setProviderIRef(provide_iref)
 
     def readAssemblySwConnectorRequesterIRef(self, element: ET.Element, parent: AssemblySwConnector):
-        child_element = element.find("./xmlns:REQUESTER-IREF", self.nsmap)
+        child_element = self.find(element, "REQUESTER-IREF")
         if (child_element is not None):
             requester_iref = RPortInCompositionInstanceRef()
             self.readElementAttributes(child_element, requester_iref)
             self.readRPortInCompositionInstanceRef(child_element, requester_iref)
-            parent.requester_iref = requester_iref
+            parent.setRequesterIRef(requester_iref)
 
     def readAssemblySwConnectors(self, element: ET.Element, parent: CompositionSwComponentType):
         for child_element in element.findall("./xmlns:CONNECTORS/xmlns:ASSEMBLY-SW-CONNECTOR", self.nsmap):
@@ -1276,26 +1417,26 @@ class ARXMLParser(AbstractARXMLParser):
             self.readAssemblySwConnectorRequesterIRef(child_element, connector)
 
     def readDelegationSwConnectorInnerPortIRef(self, element, parent: DelegationSwConnector):
-        inner_port_iref_element = element.find("./xmlns:INNER-PORT-IREF", self.nsmap)
+        inner_port_iref_element = self.find(element, "INNER-PORT-IREF")
         if (inner_port_iref_element is not None):
-            child_element = inner_port_iref_element.find("./xmlns:R-PORT-IN-COMPOSITION-INSTANCE-REF", self.nsmap)
+            child_element = self.find(inner_port_iref_element, "R-PORT-IN-COMPOSITION-INSTANCE-REF")
             if (child_element is not None):
                 r_port_in_composition_instance_ref = RPortInCompositionInstanceRef()
                 self.readRPortInCompositionInstanceRef(child_element, r_port_in_composition_instance_ref)
-                parent.inner_port_iref = r_port_in_composition_instance_ref
+                parent.setInnerPortIRref(r_port_in_composition_instance_ref)
                 return
             
-            child_element = inner_port_iref_element.find("./xmlns:P-PORT-IN-COMPOSITION-INSTANCE-REF", self.nsmap)
+            child_element = self.find(inner_port_iref_element, "P-PORT-IN-COMPOSITION-INSTANCE-REF")
             if (child_element is not None):
                 p_port_in_composition_instance_ref = PPortInCompositionInstanceRef()
                 self.readPPortInCompositionInstanceRef(child_element, p_port_in_composition_instance_ref)
-                parent.inner_port_iref = p_port_in_composition_instance_ref
+                parent.setInnerPortIRref(p_port_in_composition_instance_ref)
                 return
             
             self._raiseError("Unsupported child element of INNER-PORT-IREF")
 
     def readDelegationSwConnectors(self, element, parent: CompositionSwComponentType):
-        for child_element in element.findall("./xmlns:CONNECTORS/xmlns:DELEGATION-SW-CONNECTOR", self.nsmap):
+        for child_element in self.findall(element, "CONNECTORS/DELEGATION-SW-CONNECTOR"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readDelegationSwConnectors %s" % short_name)
 
@@ -1303,12 +1444,12 @@ class ARXMLParser(AbstractARXMLParser):
             self.readIdentifiable(child_element, connector)
             self.readDelegationSwConnectorInnerPortIRef(child_element, connector)
 
-            if connector.inner_port_iref == None and connector.outer_port_iref == None:
+            if connector.getInnerPortIRref() == None and connector.getOuterPortRef() == None:
                 self._raiseError("Invalid PortPrototype of DELEGATION-SW-CONNECTOR")
 
-            connector.outer_port_ref = self.getChildElementOptionalRefType(child_element, "OUTER-PORT-REF")
+            connector.setOuterPortRef(self.getChildElementOptionalRefType(child_element, "OUTER-PORT-REF"))
             self.logger.debug("OUTER-PORT-REF DEST: %s, %s"
-                          % (connector.outer_port_ref.dest, connector.outer_port_ref.value))
+                          % (connector.getOuterPortRef().getDest(), connector.getOuterPortRef().getValue()))
 
     def readSwComponentPrototypes(self, element: ET.Element, parent: CompositionSwComponentType):
         for child_element in element.findall("./xmlns:COMPONENTS/xmlns:SW-COMPONENT-PROTOTYPE", self.nsmap):
@@ -1316,7 +1457,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug("readSwComponentPrototypes %s" % short_name)
             prototype = parent.createSwComponentPrototype(short_name)
             self.readIdentifiable(child_element, prototype)
-            prototype.type_tref = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
+            prototype.typeTRef = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
 
     def readCompositionSwComponentTypeDataTypeMappingSet(self, element: ET.Element, parent: CompositionSwComponentType):
         child_element = element.find("./xmlns:DATA-TYPE-MAPPING-REFS", self.nsmap)
@@ -1364,30 +1505,47 @@ 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 readInvalidationPolicys(self, element: ET.Element, parent: SenderReceiverInterface):
+        for child_element in element.findall("./xmlns:INVALIDATION-POLICYS/xmlns:INVALIDATION-POLICY", self.nsmap):
+            # short_name = self.getShortName(child_element)
+            policy = parent.createInvalidationPolicy()
+            self.readIdentifiable(child_element, policy)
+            policy.data_element_ref = self.getChildElementOptionalRefType(child_element, "DATA-ELEMENT-REF")
+            policy.handle_invalid = self.getChildElementOptionalLiteral(child_element, "HANDLE-INVALID")
 
     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)
             self.readIdentifiable(child_element, prototype)
-            prototype.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
-            prototype.type_tref = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
+            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")
+            prototype.server_argument_impl_policy = self.getChildElementOptionalLiteral(child_element, "SERVER-ARGUMENT-IMPL-POLICY")
             parent.addArgumentDataPrototype(prototype)
 
     def readPossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
@@ -1408,10 +1566,11 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in element.findall("./xmlns:POSSIBLE-ERRORS/xmlns:APPLICATION-ERROR", self.nsmap):
             short_name = self.getShortName(child_element)
             error = parent.createApplicationError(short_name)
+            self.readIdentifiable(child_element, error) # some errors has its uuid
             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):
@@ -1458,6 +1617,7 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in element.findall('./xmlns:COMPU-SCALES/xmlns:COMPU-SCALE', self.nsmap):
             compu_scale = CompuScale()
             self.readElementAttributes(child_element, compu_scale)
+            compu_scale.short_label = self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")
             compu_scale.symbol = self.getChildElementOptionalLiteral(child_element, "SYMBOL")
             compu_scale.lowerLimit = self.getChildLimitElement(child_element, "LOWER-LIMIT")
             compu_scale.upperLimit = self.getChildLimitElement(child_element, "UPPER-LIMIT")
@@ -1528,14 +1688,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:
@@ -1558,7 +1718,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()
@@ -1571,8 +1731,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)
@@ -1615,7 +1775,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)
@@ -1637,11 +1801,13 @@ class ARXMLParser(AbstractARXMLParser):
         return desc
     
     def getVariableDataPrototypeInSystemInstanceRef(self, element: ET.Element) -> VariableDataPrototypeInSystemInstanceRef:
-        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")
+        iref = None
+        if element is not None:
+            iref = VariableDataPrototypeInSystemInstanceRef()
+            #iref.addContextComponentRef() = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
+            iref.setContextCompositionRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF")) \
+                .setContextPortRef(self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")) \
+                .setTargetDataPrototypeRef(self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF"))
         return iref
     
     def getEndToEndProtectionVariablePrototype(self, element: ET.Element) -> EndToEndProtectionVariablePrototype:
@@ -1683,7 +1849,21 @@ 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 readImplementationProps(self, element: ET.Element, props: ImplementationProps):
+        props.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
+
+    def readSymbolProps(self, element: ET.Element, props: SymbolProps):
+        self.readImplementationProps(element, props)
+
+    def readImplementationDataTypeSymbolProps(self, element: ET.Element, data_type: ImplementationDataType):
+        child_element = element.find("./xmlns:SYMBOL-PROPS", self.nsmap)
+        if child_element is not None:
+            short_name = self.getShortName(child_element)
+            self.logger.debug("readSymbolProps %s" % short_name)
+            props = data_type.createSymbolProps(short_name)
+            self.readSymbolProps(child_element, props)
 
     def readApplicationDataType(self, element: ET.Element, data_type: ApplicationDataType):
         self.readAutosarDataType(element, data_type)
@@ -1835,11 +2015,128 @@ class ARXMLParser(AbstractARXMLParser):
         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"):
@@ -1867,24 +2164,126 @@ class ARXMLParser(AbstractARXMLParser):
         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)
-        pdu = parent.createNmConfig(short_name)
-        self.readIdentifiable(element, pdu)
+        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)
@@ -1898,6 +2297,12 @@ class ARXMLParser(AbstractARXMLParser):
         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 = []
@@ -1949,6 +2354,274 @@ class ARXMLParser(AbstractARXMLParser):
         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 readParameterInterfaceParameters(self, element: ET.Element, parent: ParameterInterface):
+        for child_element in element.findall("./xmlns:PARAMETERS/xmlns:PARAMETER-DATA-PROTOTYPE", self.nsmap):
+            short_name = self.getShortName(child_element)
+            prototype = parent.createParameter(short_name)
+            self.readParameterDataPrototype(child_element, prototype)
+    
+    def readParameterInterface(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("ParameterInterface %s" % short_name)
+        pi_interface = parent.createParameterInterface(short_name)
+        self.readIdentifiable(element, pi_interface)
+        self.readParameterInterfaceParameters(element, pi_interface)
+
+
     def readARPackageElements(self, element: ET.Element, parent: ARPackage):
         for child_element in self.findall(element, "./ELEMENTS/*"):
             tag_name = self.getTagName(child_element.tag)
@@ -2022,38 +2695,46 @@ class ARXMLParser(AbstractARXMLParser):
                 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 == "SYSTEM":
+            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":
                 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":
                 self.readCanFrame(child_element, parent)
             elif tag_name == "I-SIGNAL":
                 self.readISignal(child_element, parent)
-                pass
             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)
+            elif tag_name == "PARAMETER-INTERFACE":
+                self.readParameterInterface(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):
@@ -2068,7 +2749,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()
@@ -2077,3 +2758,5 @@ class ARXMLParser(AbstractARXMLParser):
 
         self.getAUTOSARInfo(root, document)
         self.readARPackages(root, document)
+
+        document.reload()