armodel 1.7.0__py3-none-any.whl → 1.7.2__py3-none-any.whl

armodel/parser/arxml_parser.py

@@ -5,7 +5,6 @@ import os
 
 
 
-
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition
 from ..models.M2.MSR.AsamHdo.Constraints.GlobalConstraints import DataConstrRule, InternalConstrs, PhysConstrs, DataConstr
@@ -20,9 +19,10 @@ from ..models.M2.MSR.DataDictionary.DataDefProperties import ValueList
 from ..models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayoutGroup
 from ..models.M2.MSR.DataDictionary.CalibrationParameter import SwCalprmAxisSet
 from ..models.M2.MSR.Documentation.Annotation import Annotation, GeneralAnnotation
-from ..models.M2.MSR.Documentation.BlockElements import DocumentationBlock
-from ..models.M2.MSR.Documentation.TextModel.LanguageDataModel import LLongName, LOverviewParagraph
-from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguageOverviewParagraph, MultiLanguageParagraph, MultilanguageLongName
+from ..models.M2.MSR.Documentation.TextModel.BlockElements import DocumentationBlock
+from ..models.M2.MSR.Documentation.TextModel.BlockElements.ListElements import ListElement
+from ..models.M2.MSR.Documentation.TextModel.LanguageDataModel import LLongName, LOverviewParagraph, LParagraph, LanguageSpecific
+from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguageOverviewParagraph, MultiLanguageParagraph, MultiLanguagePlainText, MultilanguageLongName
 
 from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalBehavior, BswModuleEntity, BswScheduleEvent, BswModeSenderPolicy
@@ -36,7 +36,7 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import Res
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.MemorySectionUsage import MemorySection
 from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity, InternalBehavior
 from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping, SwcBswRunnableMapping
-from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import RoleBasedDataAssignment, ServiceDependency
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceAlgorithm, DiagEventDebounceMonitorInternal, DiagnosticEventNeeds, RoleBasedDataAssignment, RoleBasedDataTypeAssignment, ServiceDependency
 from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import Implementation
 from ..models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import ExecutionOrderConstraint
@@ -45,7 +45,7 @@ from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractRef
 from ..models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstanceRef
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject, EngineeringObject
-from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage, ReferenceBase
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType, ARLiteral
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption, PortDefinedArgumentValue
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import DataReceivedEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent
@@ -58,11 +58,11 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import Compo
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import InnerPortGroupInCompositionInstanceRef, PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef, RModeInAtomicSwcInstanceRef, RVariableInAtomicSwcInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior import RunnableEntity, RunnableEntityArgument, SwcInternalBehavior
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import CompositionSwComponentType, PortGroup, SwComponentType, SymbolProps, PPortPrototype, RPortPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import RoleBasedPortAssignment, SwcServiceDependency
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, CompositionSwComponentType, PortGroup, SwComponentType, SymbolProps, PPortPrototype, RPortPrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import AssemblySwConnector, DelegationSwConnector
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet, ModeAccessPoint
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import RoleBasedPortAssignment, SwcServiceDependency
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import ClientComSpec, ModeSwitchReceiverComSpec, ModeSwitchSenderComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, ParameterRequireComSpec, QueuedReceiverComSpec, QueuedSenderComSpec, ReceiverComSpec, SenderComSpec, ServerComSpec
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ArgumentDataPrototype, ClientServerInterface, ClientServerOperation, InvalidationPolicy, ModeSwitchInterface, ParameterInterface, PortInterface, SenderReceiverInterface
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AtomicSwComponentType
@@ -117,16 +117,20 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in self.findall(element, "./SDGS/SDG"):
             admin_data.addSdg(self.getSdg(child_element))
     
-    def readAdminData(self, element: ET.Element, identifiable: Identifiable):
-        child_element = self.find(element, "./ADMIN-DATA")
+    def getAdminData(self, element: ET.Element, key: str) -> AdminData:
+        admin_data = None
+        child_element = self.find(element, key)
         if child_element is not None:
             self.logger.debug("readAdminData")
             admin_data = AdminData()
+            admin_data.setLanguage(self.getChildElementOptionalLiteral(child_element, "LANGUAGE")) \
+                      .setUsedLanguages(self.getMultiLanguagePlainText(child_element, "USED-LANGUAGES"))
+
             self.readSdgs(child_element, admin_data)
-            identifiable.setAdminData(admin_data)
+        return admin_data
 
     def readMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
-        self.readElementAttributes(element, referrable)
+        self.readARObjectAttributes(element, referrable)
         referrable.setLongName(self.getMultilanguageLongName(element, "LONG-NAME"))
     
     def readIdentifiable(self, element: ET.Element, identifiable: Identifiable):
@@ -136,14 +140,15 @@ class ARXMLParser(AbstractARXMLParser):
             identifiable.addAnnotation(annotation)
 
         identifiable.setCategory(self.getChildElementOptionalLiteral(element, "CATEGORY")) \
-                    .setDesc(self.getMultiLanguageOverviewParagraph(element, "DESC"))
+                    .setDesc(self.getMultiLanguageOverviewParagraph(element, "DESC")) \
+                    .setIntroduction(self.getDocumentationBlock(element, "INTRODUCTION"))
         
-        self.readAdminData(element, identifiable)
+        identifiable.setAdminData(self.getAdminData(element, "ADMIN-DATA"))
     
     def readLLongName(self, element: ET.Element, long_name: MultilanguageLongName):
         for child_element in self.findall(element, "./L-4"):
             l4 = LLongName()
-            self.readElementAttributes(child_element, l4)
+            self.readARObjectAttributes(child_element, l4)
             l4.value = child_element.text
             if 'L' in child_element.attrib:
                 l4.l = child_element.attrib['L']
@@ -154,14 +159,14 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, "./%s" % key)
         if child_element is not None:
             long_name = MultilanguageLongName()
-            self.readElementAttributes(child_element, long_name)
+            self.readARObjectAttributes(child_element, long_name)
             self.readLLongName(child_element, long_name)
         return long_name
     
     def readLOverviewParagraph(self, element: ET.Element, paragraph: MultiLanguageOverviewParagraph):
         for child_element in self.findall(element, "./L-2"):
             l2 = LOverviewParagraph()
-            self.readElementAttributes(child_element, l2)
+            self.readARObjectAttributes(child_element, l2)
             l2.value = child_element.text
             if 'L' in child_element.attrib:
                 l2.l = child_element.attrib['L']
@@ -172,7 +177,7 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = element.find("./xmlns:%s" % key, self.nsmap)
         if child_element is not None:
             paragraph = MultiLanguageOverviewParagraph()
-            self.readElementAttributes(child_element, paragraph)
+            self.readARObjectAttributes(child_element, paragraph)
             self.readLOverviewParagraph(child_element, paragraph)
         return paragraph
     
@@ -180,7 +185,7 @@ class ARXMLParser(AbstractARXMLParser):
         iref  = None
         if element is not None:
             iref = VariableInAtomicSWCTypeInstanceRef()
-            self.readElementAttributes(element, iref)
+            self.readARObjectAttributes(element, iref)
             iref.setPortPrototypeRef(self.getChildElementOptionalRefType(element, "PORT-PROTOTYPE-REF"))
             iref.setTargetDataPrototypeRef(self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF"))
         return iref
@@ -189,7 +194,7 @@ class ARXMLParser(AbstractARXMLParser):
         iref  = None
         if element is not None:
             iref = ComponentInSystemInstanceRef()
-            self.readElementAttributes(element, iref)
+            self.readARObjectAttributes(element, iref)
             iref.setBaseRef(self.getChildElementOptionalRefType(element, "BASE-REF"))
             iref.setContextCompositionRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF"))
             iref.setTargetComponentRef(self.getChildElementOptionalRefType(element, "TARGET-COMPONENT-REF"))
@@ -244,7 +249,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.readIdentifiable(child_element, variable_access)
 
     def readBswModuleDescriptionImplementedEntry(self, element: ET.Element, parent: BswModuleDescription):
-        for child_element in element.findall("./xmlns:PROVIDED-ENTRYS/xmlns:BSW-MODULE-ENTRY-REF-CONDITIONAL", self.nsmap):
+        for child_element in self.findall(element, "PROVIDED-ENTRYS/BSW-MODULE-ENTRY-REF-CONDITIONAL"):
             ref = self.getChildElementOptionalRefType(child_element, "BSW-MODULE-ENTRY-REF") 
             if (ref is not None):
                 parent.addImplementedEntry(ref)
@@ -255,7 +260,7 @@ class ARXMLParser(AbstractARXMLParser):
         prototype.type_tref = self.getChildElementOptionalRefType(element, "TYPE-TREF")
 
     def readProvidedModeGroup(self, element: ET.Element, parent: BswModuleDescription):
-        for child_element in element.findall("./xmlns:PROVIDED-MODE-GROUPS/xmlns:MODE-DECLARATION-GROUP-PROTOTYPE", self.nsmap):
+        for child_element in self.findall(element, "PROVIDED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readProvidedModeGroup %s" % short_name)
 
@@ -263,7 +268,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.readModeDeclarationGroupPrototype(child_element, mode_group)
 
     def readRequiredModeGroup(self, element: ET.Element, parent: BswModuleDescription):
-        for child_element in element.findall("./xmlns:REQUIRED-MODE-GROUPS/xmlns:MODE-DECLARATION-GROUP-PROTOTYPE", self.nsmap):
+        for child_element in self.findall(element, "REQUIRED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readRequiredModeGroup %s" % short_name)
             mode_group = parent.createProvidedModeGroup(short_name)
@@ -313,7 +318,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readBswEvent(element, event)
 
     def readBswModeSwitchEvent(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:BSW-MODE-SWITCH-EVENT", self.nsmap):
+        for child_element in self.findall(element, "EVENTS/BSW-MODE-SWITCH-EVENT"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readBswModeSwitchEvent %s" % short_name)
             event = parent.createBswModeSwitchEvent(short_name)
@@ -321,29 +326,29 @@ class ARXMLParser(AbstractARXMLParser):
             self.readBswScheduleEvent(child_element, event)
 
     def readBswTimingEvent(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:BSW-TIMING-EVENT", self.nsmap):
+        for child_element in self.findall(element, "EVENTS/BSW-TIMING-EVENT"):
             short_name = self.getShortName(child_element)
-            self.logger.debug("readBswTimingEvent %s" % short_name)
+            self.logger.debug("read BswTimingEvent %s" % short_name)
             event = parent.createBswTimingEvent(short_name)
-            event.period = self.getChildElementOptionalFloatValue(child_element, "PERIOD")
+            event.setPeriod(self.getChildElementOptionalTimeValue(child_element, "PERIOD"))
             # Read the Inherit BswScheduleEvent
             self.readBswScheduleEvent(child_element, event)
 
     def readBswDataReceivedEvent(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:BSW-DATA-RECEIVED-EVENT", self.nsmap):
+        for child_element in self.findall(element, "EVENTS/BSW-DATA-RECEIVED-EVENT"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readBswDataReceivedEvent %s" % short_name)
             event = parent.createBswDataReceivedEvent(short_name)
-            event.data_ref = self.getChildElementRefType(parent.getShortName(), child_element, "DATA-REF")
+            event.dataRef = self.getChildElementRefType(parent.getShortName(), child_element, "DATA-REF")
             # Read the Inherit BswScheduleEvent
             self.readBswScheduleEvent(child_element, event)
 
     def readBswInternalTriggerOccurredEvent(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in self.findall(element, "./EVENTS/BSW-INTERNAL-TRIGGER-OCCURRED-EVENT"):
+        for child_element in self.findall(element, "EVENTS/BSW-INTERNAL-TRIGGER-OCCURRED-EVENT"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readBswInternalTriggerOccurredEvent %s" % short_name)
             event = parent.createBswInternalTriggerOccurredEvent(short_name)
-            event.event_source_ref = self.getChildElementRefType(parent.getShortName(), child_element, "EVENT-SOURCE-REF")
+            event.eventSourceRef = self.getChildElementRefType(parent.getShortName(), child_element, "EVENT-SOURCE-REF")
             # Read the Inherit BswScheduleEvent
             self.readBswScheduleEvent(child_element, event)
 
@@ -354,7 +359,7 @@ class ARXMLParser(AbstractARXMLParser):
         return policy
 
     def readBswInternalBehaviorModeSenderPolicy(self, element: ET.Element, parent: BswInternalBehavior):
-        for child_element in self.findall(element, "./MODE-SENDER-POLICYS/*"):
+        for child_element in self.findall(element, "MODE-SENDER-POLICYS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "BSW-MODE-SENDER-POLICY":
                 parent.addModeSenderPolicy(self.getBswModeSenderPolicy(child_element))
@@ -383,9 +388,9 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getRoleBasedDataAssignment(self, element: ET.Element) -> RoleBasedDataAssignment:
         assignment = RoleBasedDataAssignment()
-        assignment.role = self.getChildElementOptionalLiteral(element, "ROLE")
-        assignment.used_parameter_element = self.getAutosarParameterRef(element, "USED-PARAMETER-ELEMENT")
-        assignment.used_pim_ref = self.getChildElementOptionalRefType(element, "USED-PIM-REF")
+        assignment.setRole(self.getChildElementOptionalLiteral(element, "ROLE")) \
+                  .setUsedParameterElement(self.getAutosarParameterRef(element, "USED-PARAMETER-ELEMENT")) \
+                  .setUsedPimRef(self.getChildElementOptionalRefType(element, "USED-PIM-REF"))
         return assignment
     
     def getRoleBasedPortAssignment(self, element: ET.Element) -> RoleBasedPortAssignment:
@@ -393,12 +398,24 @@ class ARXMLParser(AbstractARXMLParser):
         assignment.portPrototypeRef = self.getChildElementOptionalRefType(element, "PORT-PROTOTYPE-REF")
         assignment.role = self.getChildElementOptionalLiteral(element, "ROLE")
         return assignment
+    
+    def getRoleBasedDataTypeAssignment(self, element: ET.Element) -> RoleBasedDataTypeAssignment:
+        assignment = RoleBasedDataTypeAssignment()
+        assignment.setRole(self.getChildElementOptionalLiteral(element, "ROLE"))
+        assignment.setUsedImplementationDataTypeRef(self.getChildElementOptionalRefType(element, "USED-IMPLEMENTATION-DATA-TYPE-REF"))
+        return assignment
 
     def readServiceDependency(self, element: ET.Element, dependency: ServiceDependency):
         self.readIdentifiable(element, dependency)
+        for child_element in self.findall(element, "ASSIGNED-DATA-TYPES/*"):
+            tag_name = self.getTagName(child_element.tag)
+            if (tag_name == "ROLE-BASED-DATA-TYPE-ASSIGNMENT"):
+                dependency.addAssignedDataType(self.getRoleBasedDataTypeAssignment(child_element))
+            else:
+                self._raiseError("Unsupported assigned data type <%s>" % tag_name)
 
     def readSwcServiceDependencyAssignedData(self, element: ET.Element, dependency: SwcServiceDependency):
-        for child_element in element.findall("./xmlns:ASSIGNED-DATAS/*", self.nsmap):
+        for child_element in self.findall(element, "ASSIGNED-DATAS/*"):
             tag_name = self.getTagName(child_element.tag)
             if (tag_name == "ROLE-BASED-DATA-ASSIGNMENT"):
                 dependency.AddAssignedData(self.getRoleBasedDataAssignment(child_element))
@@ -416,27 +433,93 @@ class ARXMLParser(AbstractARXMLParser):
     def readNvBlockNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         short_name = self.getShortName(element)
         needs = parent.createNvBlockNeeds(short_name)
-        self.logger.debug("readNvBlockNeeds %s" % short_name)
-        needs.calc_ram_block_crc = self.getChildElementOptionalBooleanValue(element, "CALC-RAM-BLOCK-CRC")
-        needs.check_static_block_id = self.getChildElementOptionalBooleanValue(element, "CHECK-STATIC-BLOCK-ID")
-        needs.n_data_sets = self.getChildElementOptionalNumericalValue(element, "N-DATA-SETS")
-        needs.n_rom_blocks = self.getChildElementOptionalNumericalValue(element, "N-ROM-BLOCKS")
-        needs.readonly = self.getChildElementOptionalBooleanValue(element, "READONLY")
-        needs.reliability = self.getChildElementOptionalLiteral(element, "RELIABILITY")
-        needs.resistant_to_changed_sw = self.getChildElementOptionalBooleanValue(element, "RESISTANT-TO-CHANGED-SW")
-        needs.restore_at_start = self.getChildElementOptionalBooleanValue(element, "RESTORE-AT-START")
-        needs.store_at_shutdown = self.getChildElementOptionalBooleanValue(element, "STORE-AT-SHUTDOWN")
-        needs.write_only_once = self.getChildElementOptionalBooleanValue(element, "WRITE-ONLY-ONCE")
-        needs.write_verification = self.getChildElementOptionalBooleanValue(element, "WRITE-VERIFICATION")
-        needs.writing_priority = self.getChildElementOptionalLiteral(element, "WRITING-PRIORITY")                          
+        self.logger.debug("read NvBlockNeeds %s" % short_name)
+        needs.setCalcRamBlockCrc(self.getChildElementOptionalBooleanValue(element, "CALC-RAM-BLOCK-CRC")) \
+             .setCheckStaticBlockId(self.getChildElementOptionalBooleanValue(element, "CHECK-STATIC-BLOCK-ID")) \
+             .setNDataSets(self.getChildElementOptionalNumericalValue(element, "N-DATA-SETS")) \
+             .setNRomBlocks(self.getChildElementOptionalNumericalValue(element, "N-ROM-BLOCKS")) \
+             .setRamBlockStatusControl(self.getChildElementOptionalLiteral(element, "RAM-BLOCK-STATUS-CONTROL")) \
+             .setReadonly(self.getChildElementOptionalBooleanValue(element, "READONLY")) \
+             .setReliability(self.getChildElementOptionalLiteral(element, "RELIABILITY")) \
+             .setResistantToChangedSw(self.getChildElementOptionalBooleanValue(element, "RESISTANT-TO-CHANGED-SW")) \
+             .setRestoreAtStart(self.getChildElementOptionalBooleanValue(element, "RESTORE-AT-START")) \
+             .setStoreAtShutdown(self.getChildElementOptionalBooleanValue(element, "STORE-AT-SHUTDOWN")) \
+             .setStoreCyclic(self.getChildElementOptionalBooleanValue(element, "STORE-CYCLIC")) \
+             .setStoreEmergency(self.getChildElementOptionalBooleanValue(element, "STORE-EMERGENCY")) \
+             .setStoreImmediate(self.getChildElementOptionalBooleanValue(element, "STORE-IMMEDIATE")) \
+             .setUseAutoValidationAtShutDown(self.getChildElementOptionalBooleanValue(element, "USE-AUTO-VALIDATION-AT-SHUT-DOWN")) \
+             .setUseCRCCompMechanism(self.getChildElementOptionalBooleanValue(element, "USE-CRC-COMP-MECHANISM")) \
+             .setWriteOnlyOnce(self.getChildElementOptionalBooleanValue(element, "WRITE-ONLY-ONCE")) \
+             .setWriteVerification(self.getChildElementOptionalBooleanValue(element, "WRITE-VERIFICATION")) \
+             .setWritingPriority(self.getChildElementOptionalLiteral(element, "WRITING-PRIORITY"))
+        
+    def reaDiagnosticCommunicationManagerNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createDiagnosticCommunicationManagerNeeds(short_name)
+        self.logger.debug("read DiagnosticCommunicationManagerNeeds %s" % short_name)
+        needs.setServiceRequestCallbackType(self.getChildElementOptionalLiteral(element, "SERVICE-REQUEST-CALLBACK-TYPE"))
+
+    def readDiagnosticRoutineNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createDiagnosticRoutineNeeds(short_name)
+        self.logger.debug("read DiagnosticRoutineNeeds %s" % short_name)
+        needs.setDiagRoutineType(self.getChildElementOptionalLiteral(element, "DIAG-ROUTINE-TYPE")) \
+             .setRidNumber(self.getChildElementOptionalIntegerValue(element, "RID-NUMBER"))
+
+    def readDiagnosticValueNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createDiagnosticValueNeeds(short_name)
+        self.logger.debug("read DiagnosticValueNeeds %s" % short_name)
+        needs.setDataLength(self.getChildElementOptionalPositiveInteger(element, "DATA-LENGTH")) \
+             .setDiagnosticValueAccess(self.getChildElementOptionalLiteral(element, "DIAGNOSTIC-VALUE-ACCESS")) \
+             .setDidNumber(self.getChildElementOptionalIntegerValue(element, "DID-NUMBER")) \
+             .setFixedLength(self.getChildElementOptionalBooleanValue(element, "FIXED-LENGTH")) \
+             .setProcessingStyle(self.getChildElementOptionalLiteral(element, "PROCESSING-STYLE"))
+        
+    def readDiagEventDebounceMonitorInternal(self, element: ET.Element, algorithm: DiagEventDebounceMonitorInternal):
+        self.readIdentifiable(element, algorithm)
+        
+    def readDiagEventDebounceAlgorithm(self, element: ET.Element, needs: DiagnosticEventNeeds):
+        for child_element in self.findall(element, "DIAG-EVENT-DEBOUNCE-ALGORITHM/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DIAG-EVENT-DEBOUNCE-MONITOR-INTERNAL":
+                algorithm = needs.createDiagEventDebounceMonitorInternal(self.getShortName(child_element))
+                self.readDiagEventDebounceMonitorInternal(child_element, algorithm)
+            else:
+                self.notImplemented("Unsupported DiagEventDebounceAlgorithm <%s>" % tag_name)
+    
+    def readDiagnosticEventNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createDiagnosticEventNeeds(short_name)
+        self.logger.debug("read DiagnosticEventNeeds %s" % short_name)
+        
+        self.readDiagEventDebounceAlgorithm(element, needs)
+        needs.setDtcKind(self.getChildElementOptionalLiteral(element, "DTC-KIND")) \
+             .setUdsDtcNumber(self.getChildElementOptionalIntegerValue(element, "UDS-DTC-NUMBER")) 
+
+    def readCryptoServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createCryptoServiceNeeds(short_name)
+        self.logger.debug("read DiagnosticValueNeeds %s" % short_name)
+        needs.setMaximumKeyLength(self.getChildElementOptionalPositiveInteger(element, "MAXIMUM-KEY-LENGTH"))
 
     def readSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         for child_element in element.findall("./xmlns:SERVICE-NEEDS/*", self.nsmap):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "NV-BLOCK-NEEDS":
                 self.readNvBlockNeeds(child_element, parent)    
+            elif tag_name == "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS":
+                self.reaDiagnosticCommunicationManagerNeeds(child_element, parent)
+            elif tag_name == "DIAGNOSTIC-ROUTINE-NEEDS":
+                self.readDiagnosticRoutineNeeds(child_element, parent)
+            elif tag_name == "DIAGNOSTIC-VALUE-NEEDS":
+                self.readDiagnosticValueNeeds(child_element, parent)
+            elif tag_name == "DIAGNOSTIC-EVENT-NEEDS":
+                self.readDiagnosticEventNeeds(child_element, parent)
+            elif tag_name == "CRYPTO-SERVICE-NEEDS":
+                self.readCryptoServiceNeeds(child_element, parent)
             else:
-                self._raiseError("Unsupported service needs <%s>" % tag_name)
+                self.notImplemented("Unsupported service needs <%s>" % tag_name)
 
     def readSwcServiceDependency(self, element: ET.Element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
@@ -459,7 +542,7 @@ class ARXMLParser(AbstractARXMLParser):
         include_data_type_sets = []
         for child_element in self.findall(element, "./INCLUDED-DATA-TYPE-SETS/INCLUDED-DATA-TYPE-SET"):
             include_data_type_set = IncludedDataTypeSet()
-            self.readElementAttributes(child_element, include_data_type_set)
+            self.readARObjectAttributes(child_element, include_data_type_set)
             for ref_type in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-REFS/DATA-TYPE-REF"):
                 include_data_type_set.addDataTypeRef(ref_type)
             include_data_type_sets.append(include_data_type_set)
@@ -540,7 +623,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("readBswModuleEntry %s" % entry.getShortName())
 
     def readEngineeringObject(self, element: ET.Element, engineering_obj: EngineeringObject):
-        self.readElementAttributes(element, engineering_obj)
+        self.readARObjectAttributes(element, engineering_obj)
         engineering_obj.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
                        .setCategory(self.getChildElementOptionalLiteral(element, "CATEGORY"))
         
@@ -574,14 +657,14 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readMemorySections(self, element: ET.Element, consumption: ResourceConsumption):
         for child_element in element.findall("./xmlns:MEMORY-SECTIONS/xmlns:MEMORY-SECTION", self.nsmap):
-            short_name = self.getShortName(child_element)
-            memory_section = consumption.createMemorySection(short_name)
+            memory_section = consumption.createMemorySection(self.getShortName(child_element))
             self.readIdentifiable(child_element, memory_section)
-            memory_section.setAlignment(self.getChildElementOptionalLiteral(child_element, "ALIGNMENT"))
+            memory_section.setAlignment(self.getChildElementOptionalLiteral(child_element, "ALIGNMENT")) \
+                          .setMemClassSymbol(self.getChildElementOptionalLiteral(child_element, "MEM-CLASS-SYMBOL")) 
             self.readMemorySectionOptions(child_element, memory_section)
-            memory_section.size = self.getChildElementOptionalNumericalValue(child_element, "SIZE")
-            memory_section.swAddrMethodRef = self.getChildElementOptionalRefType(child_element, "SW-ADDRMETHOD-REF")
-            memory_section.symbol = self.getChildElementOptionalLiteral(child_element, "SYMBOL")
+            memory_section.setSize(self.getChildElementOptionalNumericalValue(child_element, "SIZE")) \
+                          .setSwAddrMethodRef(self.getChildElementOptionalRefType(child_element, "SW-ADDRMETHOD-REF")) \
+                          .setSymbol(self.getChildElementOptionalLiteral(child_element, "SYMBOL"))
             self.logger.debug("readMemorySections %s" % memory_section.getShortName())
 
     def readResourceConsumption(self, element: ET.Element, impl: Implementation):
@@ -667,11 +750,12 @@ class ARXMLParser(AbstractARXMLParser):
         self._readVariableAccesses(element, parent, "READ-LOCAL-VARIABLES")
 
     def readROperationIRef(self, element: ET.Element, key: str, parent: ServerCallPoint):
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, key)
         if (child_element is not None):
             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")
+            self.readARObjectAttributes(child_element, operation_iref)
+            operation_iref.setContextRPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")) \
+                          .setTargetRequiredOperationRef(self.getChildElementOptionalRefType(child_element, "TARGET-REQUIRED-OPERATION-REF"))
             parent.setOperationIRef(operation_iref)
 
     def readRVariableInAtomicSwcInstanceRef(self, element: ET.Element, parent: DataReceivedEvent):
@@ -683,7 +767,7 @@ class ARXMLParser(AbstractARXMLParser):
             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):
+        for child_element in self.findall(element, "MODE-IREFS/MODE-IREF"):
             mode_iref = RModeInAtomicSwcInstanceRef()
             mode_iref.setContextPortRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF")) \
                      .setContextModeDeclarationGroupPrototypeRef(self.getChildElementOptionalRefType(child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")) \
@@ -765,18 +849,23 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "RUNNABLE-ENTITY-ARGUMENT":
                 entity.addArgument(self.getRunnableEntityArgument(child_element))
             else:
-                raise NotImplementedError("Unsupported Arguments of runnable entity <%s>" % tag_name)
+                self.notImplemented("Unsupported Arguments of runnable entity <%s>" % tag_name)
+
+    def readAsynchronousServerCallResultPoint(self, element: ET.Element, entity: RunnableEntity):
+        for child_element in self.findall(element, "ASYNCHRONOUS-SERVER-CALL-RESULT-POINTS/ASYNCHRONOUS-SERVER-CALL-RESULT-POINT"):
+            point = entity.createAsynchronousServerCallResultPoint(self.getShortName(child_element))
+            self.readIdentifiable(child_element, point)
+            point.setAsynchronousServerCallPointRef(self.getChildElementOptionalRefType(child_element, "ASYNCHRONOUS-SERVER-CALL-POINT-REF"))
 
     def readRunnableEntity(self, element: ET.Element, entity: RunnableEntity):
         self.readExecutableEntity(element, entity)
         self.readRunnableEntityArguments(element, entity)
 
+        self.readAsynchronousServerCallResultPoint(element, entity)
         entity.setCanBeInvokedConcurrently(self.getChildElementOptionalBooleanValue(element, "CAN-BE-INVOKED-CONCURRENTLY"))
-        entity.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
-
+        self.readDataReadAccesses(element, entity)
         self.readDataReceivePointByArguments(element, entity)
         self.readDataReceivePointByValues(element, entity)
-        self.readDataReadAccesses(element, entity)
         self.readDataWriteAccesses(element, entity)
         self.readDataSendPoints(element, entity)
         self.readInternalBehaviorServerCallPoint(element, entity)
@@ -787,6 +876,8 @@ class ARXMLParser(AbstractARXMLParser):
         self.readReadLocalVariables(element, entity)
         self.readWrittenLocalVariables(element, entity)
 
+        entity.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
+
     def readSwcInternalBehaviorRunnables(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in self.findall(element, "RUNNABLES/RUNNABLE-ENTITY"):
             short_name = self.getShortName(child_element)
@@ -810,17 +901,19 @@ class ARXMLParser(AbstractARXMLParser):
             iref = self.getRModeInAtomicSwcInstanceRef(child_element)
             event.addDisabledModeIRef(iref)
 
-    def readOperationIRef(self, element: ET.Element, parent: OperationInvokedEvent):
-        child_element = element.find("./xmlns:OPERATION-IREF", self.nsmap)
+    def readPOperationIRef(self, element: ET.Element, key: str, parent: OperationInvokedEvent):
+        child_element = self.find(element, key)
         if (child_element is not None):
-            parent.operationIRef = POperationInAtomicSwcInstanceRef()
-            parent.operationIRef.context_p_port_ref = self.getChildElementRefType(parent.getShortName(), child_element, "CONTEXT-P-PORT-REF")
-            parent.operationIRef.target_provided_operation_ref = self.getChildElementRefType(parent.getShortName(), child_element, "TARGET-PROVIDED-OPERATION-REF")
+            operation_iref = POperationInAtomicSwcInstanceRef()
+            self.readARObjectAttributes(child_element, operation_iref)
+            operation_iref.setContextPPortRef(self.getChildElementRefType(parent.getShortName(), child_element, "CONTEXT-P-PORT-REF")) \
+                          .setTargetProvidedOperationRef(self.getChildElementRefType(parent.getShortName(), child_element, "TARGET-PROVIDED-OPERATION-REF"))
+            parent.setOperationIRef(operation_iref)
 
     def readOperationInvokedEvent(self, element: ET.Element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
         event = parent.createOperationInvokedEvent(short_name)
-        self.readOperationIRef(element, event)
+        self.readPOperationIRef(element, "OPERATION-IREF", event)
         self.readRTEEvent(element, event)
 
     def readVariableDataPrototype(self, element: ET.Element, prototype: VariableDataPrototype):
@@ -828,13 +921,13 @@ class ARXMLParser(AbstractARXMLParser):
         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):
+        for child_element in self.findall(element, "EXPLICIT-INTER-RUNNABLE-VARIABLES/VARIABLE-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = parent.createExplicitInterRunnableVariable(short_name)
             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):
+        for child_element in self.findall(element, "PER-INSTANCE-MEMORYS/PER-INSTANCE-MEMORY"):
             short_name = self.getShortName(child_element)
             memory = behavior.createPerInstanceMemory(short_name)
             self.readIdentifiable(child_element, memory)
@@ -853,26 +946,26 @@ class ARXMLParser(AbstractARXMLParser):
         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):
+        for child_element in self.findall(element, "PER-INSTANCE-PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = behavior.createPerInstanceParameter(short_name)
             self.readParameterDataPrototype(child_element, prototype)
 
     def readPortDefinedArgumentValue(self, element: ET.Element) -> PortDefinedArgumentValue:
         argument_value = PortDefinedArgumentValue()
-        child_element = element.find("./xmlns:VALUE/*", self.nsmap)
+        child_element = self.find(element, "VALUE/*")
         if child_element is not None:
             argument_value.value = self.getValueSpecification(child_element)
         argument_value.valueTypeTRef = self.getChildElementOptionalRefType(element, "VALUE-TYPE-TREF")
         return argument_value
 
     def readPortAPIOptions(self, element: ET.Element, behavior: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:PORT-API-OPTIONS/xmlns:PORT-API-OPTION", self.nsmap):
+        for child_element in self.findall(element, "PORT-API-OPTIONS/PORT-API-OPTION"):
             option = PortAPIOption()
             option.enableTakeAddress = self.getChildElementOptionalBooleanValue(child_element, "ENABLE-TAKE-ADDRESS")
             option.indirectAPI = self.getChildElementOptionalBooleanValue(child_element, "INDIRECT-API")
             option.portRef = self.getChildElementOptionalRefType(child_element, "PORT-REF")
-            for argument_value_tag in child_element.findall("./xmlns:PORT-ARG-VALUES/xmlns:PORT-DEFINED-ARGUMENT-VALUE", self.nsmap):
+            for argument_value_tag in self.findall(child_element, "PORT-ARG-VALUES/PORT-DEFINED-ARGUMENT-VALUE"):
                 option.addPortArgValue(self.readPortDefinedArgumentValue(argument_value_tag))
             behavior.addPortAPIOption(option)
             
@@ -880,8 +973,8 @@ class ARXMLParser(AbstractARXMLParser):
         short_name = self.getShortName(element)
         event = parent.createTimingEvent(short_name)
         self.readRTEEvent(element, event)
-        event.offset = self.getChildElementOptionalFloatValue(element, "OFFSET")
-        event.period = self.getChildElementOptionalFloatValue(element, "PERIOD")
+        event.setOffset(self.getChildElementOptionalTimeValue(element, "OFFSET")) \
+             .setPeriod(self.getChildElementOptionalTimeValue(element, "PERIOD"))
 
     def readDataReceivedEvent(self, element: ET.Element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
@@ -893,22 +986,28 @@ class ARXMLParser(AbstractARXMLParser):
         short_name = self.getShortName(element)
         event = parent.createSwcModeSwitchEvent(short_name)
         self.readRTEEvent(element, event)
-        event.activation = self.getChildElementOptionalLiteral(element, "ACTIVATION")
+        event.setActivation(self.getChildElementOptionalLiteral(element, "ACTIVATION"))
         self.readRModeInAtomicSwcInstanceRef(element, event)
 
     def readInternalTriggerOccurredEvent(self, element: ET.Element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
         event = parent.createInternalTriggerOccurredEvent(short_name)
         self.readRTEEvent(element, event)
-        event.event_source_ref = self.getChildElementRefType(parent.getShortName(), element, "EVENT-SOURCE-REF")
+        event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
     def readInitEvent(self, element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
         event = parent.createInitEvent(short_name)
         self.readRTEEvent(element, event)
 
+    def readAsynchronousServerCallReturnsEvent(self, element, parent: SwcInternalBehavior):
+        short_name = self.getShortName(element)
+        event = parent.createAsynchronousServerCallReturnsEvent(short_name)
+        self.readRTEEvent(element, event)
+        event.setActivationReasonRepresentationRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
+
     def readSwcInternalBehaviorEvents(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/*", self.nsmap):
+        for child_element in self.findall(element, "EVENTS/*"):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "TIMING-EVENT":
                 self.readTimingEvent(child_element, parent)
@@ -922,44 +1021,97 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readInternalTriggerOccurredEvent(child_element, parent)
             elif tag_name == "INIT-EVENT":
                 self.readInitEvent(child_element, parent)
+            elif tag_name == "ASYNCHRONOUS-SERVER-CALL-RETURNS-EVENT":
+                self.readAsynchronousServerCallReturnsEvent(child_element, parent)
             else:
-                self._raiseError("Unsupported SwcInternalBehavior Event <%s>" % tag_name)
+                self.notImplemented("Unsupported SwcInternalBehavior Event <%s>" % tag_name)
 
     def readSwPointerTargetProps(self, element: ET.Element, parent: SwDataDefProps):
         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")
+            sw_pointer_target_props.setTargetCategory(self.getChildElementOptionalLiteral(child_element, "TARGET-CATEGORY")) \
+                                   .setSwDataDefProps(self.getSwDataDefProps(child_element, "SW-DATA-DEF-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 readLanguageSpecific(self, element: ET.Element, specific: LanguageSpecific):
+        self.readARObjectAttributes(element, specific)
+        specific.value = element.text
+        if 'L' in element.attrib:
+            specific.l = element.attrib['L']
+
+    def getLParagraphs(self, element: ET.Element, key: str) -> List[LParagraph]:
+        results = []
+        for child_element in self.findall(element, key):
+            l1 = LParagraph()
+            self.readLanguageSpecific(child_element, l1)
+            results.append(l1)
+        return results
     
     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)
+            self.readARObjectAttributes(child_element, paragraph)
+            for l1 in self.getLParagraphs(child_element, "L-1"):
+                paragraph.addL1(l1)
             paragraphs.append(paragraph)
         return paragraphs
+    
+    def getLPlainTexts(self, element: ET.Element, key: str) -> List[LParagraph]:
+        results = []
+        for child_element in self.findall(element, key):
+            l1 = LParagraph()
+            self.readLanguageSpecific(child_element, l1)
+            results.append(l1)
+        return results
+    
+    def getListElements(self, element: ET.Element, key: str) -> List[ListElement]:
+        '''
+            Read the DocumentationBlock List
+        '''
+        result = []
+        for child_element in self.findall(element, key):
+            list = ListElement()
+            if 'TYPE' in child_element.attrib:
+                list.setType(child_element.attrib['TYPE'])
+            for block in self.getDocumentationBlockList(child_element, "ITEM"):
+                list.addItem(block)
+            result.append(list)
+        return result       
+    
+    def getMultiLanguagePlainText(self, element: ET.Element, key: str) -> MultiLanguagePlainText:
+        paragraph = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            paragraph = MultiLanguagePlainText()
+            self.readARObjectAttributes(child_element, paragraph)
+            for l10 in self.getLPlainTexts(child_element, "L-10"):
+                paragraph.addL10(l10)
+        return paragraph
+    
+    def readDocumentationBlock(self, element: ET.Element, block: DocumentationBlock):
+        self.readARObjectAttributes(element, block)
+        for paragraph in self.getMultiLanguageParagraphs(element, "P"):
+            block.addP(paragraph)
+        for list in self.getListElements(element, "LIST"):
+            block.addList(list)
 
     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)
+            self.readDocumentationBlock(child_element, block)
         return block
+    
+    def getDocumentationBlockList(self, element: ET.Element, key: str) -> List[DocumentationBlock]:
+        blocks = []
+        for child_element in self.findall(element, key):
+            block = DocumentationBlock()
+            self.readDocumentationBlock(child_element, block)
+            blocks.append(block)
+        return blocks
 
     def readGeneralAnnotation(self, element: ET.Element, annotation: GeneralAnnotation):
         annotation.setAnnotationOrigin(self.getChildElementOptionalLiteral(element, 'ANNOTATION-ORIGIN')) \
@@ -968,7 +1120,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getAnnotations(self, element: ET.Element) -> List[Annotation]:
         annotations = []
-        for child_element in element.findall("./xmlns:ANNOTATIONS/xmlns:ANNOTATION", self.nsmap):
+        for child_element in self.findall(element, "ANNOTATIONS/ANNOTATION"):
             annotation = Annotation()
             self.readGeneralAnnotation(child_element, annotation)
             annotations.append(annotation)
@@ -976,7 +1128,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getSwAxisIndividual(self, element: ET.Element) -> SwAxisIndividual:
         props = SwAxisIndividual()
-        self.readElementAttributes(element, props)
+        self.readARObjectAttributes(element, props)
         props.setInputVariableTypeRef(self.getChildElementOptionalRefType(element, "INPUT-VARIABLE-TYPE-REF")) \
              .setCompuMethodRef(self.getChildElementOptionalRefType(element, "COMPU-METHOD-REF")) \
              .setSwMaxAxisPoints(self.getChildElementOptionalNumericalValue(element, "SW-MAX-AXIS-POINTS")) \
@@ -993,10 +1145,10 @@ class ARXMLParser(AbstractARXMLParser):
         axis = SwCalprmAxis()
         axis.sw_axis_index = self.getChildElementOptionalNumericalValue(element, "SW-AXIS-INDEX")
         axis.category = self.getChildElementOptionalLiteral(element, "CATEGORY")
-        child_element = element.find("./xmlns:SW-AXIS-INDIVIDUAL", self.nsmap)
+        child_element = self.find(element, "SW-AXIS-INDIVIDUAL")
         if child_element is not None:
             axis.sw_calprm_axis_type_props = self.getSwAxisIndividual(child_element)
-        child_element = element.find("./xmlns:SW-AXIS-GROUPED", self.nsmap)
+        child_element = self.find(element, "SW-AXIS-GROUPED")
         if child_element is not None:
             axis.sw_calprm_axis_type_props = self.getSwAxisGrouped(child_element)
         
@@ -1004,7 +1156,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def getSwCalprmAxisSet(self, element: ET.Element, key: str) -> SwCalprmAxisSet:
         set = SwCalprmAxisSet()
-        for child_element in element.findall("./xmlns:%s/*" % key, self.nsmap):
+        for child_element in self.findall(element, "%s/*" % key):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "SW-CALPRM-AXIS":
                 set.addSwCalprmAxis(self.getSwCalprmAxis(child_element))
@@ -1016,13 +1168,13 @@ class ARXMLParser(AbstractARXMLParser):
             props.setInvalidValue(self.getValueSpecification(child_element))
 
     def getSwDataDefProps(self, element: ET.Element, key: str) -> SwDataDefProps:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, key)
         sw_data_def_props = None
         if child_element is not None:
-            conditional_tag = child_element.find("./xmlns:SW-DATA-DEF-PROPS-VARIANTS/xmlns:SW-DATA-DEF-PROPS-CONDITIONAL", self.nsmap)
+            conditional_tag = self.find(child_element, "SW-DATA-DEF-PROPS-VARIANTS/SW-DATA-DEF-PROPS-CONDITIONAL")
             if conditional_tag is not None:
                 sw_data_def_props = SwDataDefProps()
-                self.readElementAttributes(child_element, sw_data_def_props)
+                self.readARObjectAttributes(child_element, sw_data_def_props)
 
                 for annotation in self.getAnnotations(conditional_tag):
                     sw_data_def_props.addAnnotation(annotation)
@@ -1030,7 +1182,9 @@ class ARXMLParser(AbstractARXMLParser):
                 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")) \
+                                 .setSwAddrMethodRef(self.getChildElementOptionalRefType(conditional_tag, "SW-ADDR-METHOD-REF")) \
                                  .setSwImplPolicy(self.getChildElementOptionalLiteral(conditional_tag, "SW-IMPL-POLICY")) \
+                                 .setSwIntendedResolution(self.getChildElementOptionalNumericalValue(conditional_tag, "SW-INTENDED-RESOLUTION")) \
                                  .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")) \
@@ -1039,7 +1193,7 @@ class ARXMLParser(AbstractARXMLParser):
                                  .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)
+                self.readARObjectAttributes(conditional_tag, sw_data_def_props.conditional)
         return sw_data_def_props
     
     def readAutosarDataType(self, element: ET.Element, data_type: AutosarDataType):
@@ -1056,7 +1210,7 @@ class ARXMLParser(AbstractARXMLParser):
         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):
+        for child_element in self.findall(element, "ELEMENTS/APPLICATION-RECORD-ELEMENT"):
             short_name = self.getShortName(child_element)
             record_element = parent.createApplicationRecordElement(short_name)
             self.logger.debug("readApplicationRecordElements %s" % short_name)
@@ -1073,10 +1227,10 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readImplementationDataTypeElements(self, element: ET.Element, parent: ImplementationDataType):
         for child_element in self.findall(element, "SUB-ELEMENTS/IMPLEMENTATION-DATA-TYPE-ELEMENT"):
-            short_name = self.getShortName(child_element)
-            type_element = parent.createImplementationDataTypeElement(short_name)
+            type_element = parent.createImplementationDataTypeElement(self.getShortName(child_element))
             self.readIdentifiable(child_element, type_element)
             type_element.setArraySize(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE")) \
+                        .setArraySizeHandling(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-HANDLING")) \
                         .setArraySizeSemantics(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS"))
             self.readImplementationDataTypeElements(child_element, type_element)
             type_element.setSwDataDefProps(self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS"))
@@ -1085,6 +1239,7 @@ class ARXMLParser(AbstractARXMLParser):
         short_name = self.getShortName(element)
         data_type = parent.createImplementationDataType(short_name)
         self.readAutosarDataType(element, data_type)
+        data_type.setDynamicArraySizeProfile(self.getChildElementOptionalLiteral(element, "DYNAMIC-ARRAY-SIZE-PROFILE"))
         self.readImplementationDataTypeElements(element, data_type)
         data_type.setTypeEmitter(self.getChildElementOptionalLiteral(element, "TYPE-EMITTER"))
         
@@ -1129,7 +1284,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readBaseTypeDirectDefinition(element, data_type.baseTypeDefinition)
 
     def getApplicationCompositeElementInPortInterfaceInstanceRef(self, element: ET.Element, key:str) -> ApplicationCompositeElementInPortInterfaceInstanceRef:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        child_element = self.find(element, key)
         iref = None
         if child_element is not None:
             iref = ApplicationCompositeElementInPortInterfaceInstanceRef()
@@ -1140,25 +1295,26 @@ class ARXMLParser(AbstractARXMLParser):
     def getCompositeNetworkRepresentation(self, element: ET.Element) -> CompositeNetworkRepresentation:
         self.logger.debug("getCompositeNetworkRepresentation")
         representation = CompositeNetworkRepresentation()
-        representation.leaf_element_iref = self.getApplicationCompositeElementInPortInterfaceInstanceRef(element, "LEAF-ELEMENT-IREF")
-        representation.network_representation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
+        representation.setLeafElementIRef(self.getApplicationCompositeElementInPortInterfaceInstanceRef(element, "LEAF-ELEMENT-IREF")) \
+                      .setNetworkRepresentation(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION"))
         return representation
 
     def readReceiverComSpec(self, element: ET.Element, com_spec: ReceiverComSpec):
-        self.readElementAttributes(element, com_spec)
+        self.readARObjectAttributes(element, com_spec)
         for child_element in self.findall(element, "COMPOSITE-NETWORK-REPRESENTATIONS/COMPOSITE-NETWORK-REPRESENTATION"):
             com_spec.addCompositeNetworkRepresentation(self.getCompositeNetworkRepresentation(child_element))
-        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")
+        com_spec.setDataElementRef(self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")) \
+                .setNetworkRepresentation(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")) \
+                .setHandleOutOfRange(self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE")) \
+                .setHandleOutOfRangeStatus(self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE-STATUS")) \
+                .setUsesEndToEndProtection(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
         if child_element is None:
             return None
         sw_values = SwValues()
-        self.readElementAttributes(child_element, sw_values)
+        self.readARObjectAttributes(child_element, sw_values)
         for v in self.getChildElementFloatValueList(child_element, "V"):
             sw_values.addV(v)
         sw_values.vt = self.getChildElementOptionalLiteral(child_element, "VT")
@@ -1170,7 +1326,7 @@ class ARXMLParser(AbstractARXMLParser):
         if child_element is not None:
             self.logger.debug("getValueList %s" % key)
             value_list = ValueList()
-            self.readElementAttributes(child_element, value_list)
+            self.readARObjectAttributes(child_element, value_list)
             value_list.v = self.getChildElementOptionalFloatValue(child_element, "V")
         return value_list
 
@@ -1180,7 +1336,7 @@ class ARXMLParser(AbstractARXMLParser):
         if child_element is not None:
             self.logger.debug("getSwValueCont")
             cont = SwValueCont()
-            self.readElementAttributes(child_element, cont)
+            self.readARObjectAttributes(child_element, cont)
             cont.unit_ref = self.getChildElementOptionalRefType(child_element, "UNIT-REF")
             cont.sw_arraysize = self.getValueList(child_element, "SW-ARRAYSIZE")
             cont.sw_values_phys = self.getSwValues(child_element, "SW-VALUES-PHYS")
@@ -1203,43 +1359,43 @@ class ARXMLParser(AbstractARXMLParser):
     
     def getClientComSpec(self, element: ET.Element) -> ClientComSpec:
         com_spec = ClientComSpec()
-        self.readElementAttributes(element, com_spec)
+        self.readARObjectAttributes(element, com_spec)
         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)
+        self.readARObjectAttributes(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.readARObjectAttributes(element, com_spec)
         self.readReceiverComSpec(element, com_spec)
         com_spec.queueLength = self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH")
         return com_spec
     
     def getModeSwitchReceiverComSpec(self, element: ET.Element) -> ModeSwitchReceiverComSpec:
         com_spec = ModeSwitchReceiverComSpec()
-        self.readElementAttributes(element, com_spec)
+        self.readARObjectAttributes(element, com_spec)
         com_spec.modeGroupRef = self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")
         return com_spec
 
     def getNonqueuedReceiverComSpec(self, element: ET.Element) -> NonqueuedReceiverComSpec:
         com_spec = NonqueuedReceiverComSpec()
-        self.readElementAttributes(element, com_spec)            
+        self.readARObjectAttributes(element, com_spec)            
         self.readReceiverComSpec(element, com_spec)
-        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)
+        com_spec.setAliveTimeout(self.getChildElementOptionalFloatValue(element, "ALIVE-TIMEOUT")) \
+                .setEnableUpdated(self.getChildElementOptionalBooleanValue(element, "ENABLE-UPDATE")) \
+                .setHandleNeverReceived(self.getChildElementOptionalBooleanValue(element, "HANDLE-NEVER-RECEIVED")) \
+                .setHandleTimeoutType(self.getChildElementOptionalLiteral(element, "HANDLE-TIMEOUT-TYPE")) \
+                .setInitValue(self.getInitValue(element))
         return com_spec
 
     def readRequiredComSpec(self, element: ET.Element, parent: RPortPrototype):
-        for child_element in element.findall("./xmlns:REQUIRED-COM-SPECS/*", self.nsmap):
+        for child_element in self.findall(element, "REQUIRED-COM-SPECS/*"):
             tag_name = self.getTagName(child_element.tag)
             if tag_name == "NONQUEUED-RECEIVER-COM-SPEC":
                 parent.addRequiredComSpec(self.getNonqueuedReceiverComSpec(child_element))
@@ -1254,14 +1410,36 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
+    def readAbstractRequiredPortPrototype(self, element: ET.Element, prototype: AbstractRequiredPortPrototype):
+        self.readProvidedComSpec(element, prototype)
+
+    def readPPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
+        short_name = self.getShortName(element)
+        self.logger.debug("readPPortPrototype %s" % short_name)
+        prototype = parent.createPPortPrototype(short_name)
+        self.readIdentifiable(element, prototype)
+        self.readAbstractRequiredPortPrototype(element, prototype)
+        prototype.setProvidedInterfaceTRef(self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF"))
+        
+    def readAbstractProvidedPortPrototype(self, element: ET.Element, prototype: AbstractProvidedPortPrototype):
+        self.readRequiredComSpec(element, prototype)
+
     def readRPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
         short_name = self.getShortName(element)
-        self.logger.debug("readRPortPrototype %s" % short_name)
+        self.logger.debug("read RPortPrototype %s" % short_name)
         prototype = parent.createRPortPrototype(short_name)
         self.readIdentifiable(element, prototype)
+        self.readAbstractProvidedPortPrototype(element, prototype)
         prototype.setRequiredInterfaceTRef(self.getChildElementOptionalRefType(element, "REQUIRED-INTERFACE-TREF"))
 
-        self.readRequiredComSpec(element, prototype)
+    def readPRPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
+        short_name = self.getShortName(element)
+        self.logger.debug("read PRPortPrototype %s" % short_name)
+        prototype = parent.createPRPortPrototype(short_name)
+        self.readIdentifiable(element, prototype)
+        self.readAbstractRequiredPortPrototype(element, prototype)
+        self.readAbstractProvidedPortPrototype(element, prototype)
+        prototype.setProvidedRequiredInterface(self.getChildElementOptionalRefType(element, "PROVIDED-REQUIRED-INTERFACE-TREF"))
 
     def readAtomicSwComponentTypePorts(self, element: ET.Element, sw_component: AtomicSwComponentType):
         for child_element in self.findall(element, "PORTS/*"):
@@ -1270,6 +1448,8 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readPPortPrototype(child_element, sw_component)
             elif tag_name == "R-PORT-PROTOTYPE":
                 self.readRPortPrototype(child_element, sw_component)
+            elif tag_name == "PR-PORT-PROTOTYPE":
+                self.readPRPortPrototype(child_element, sw_component)
             else:
                 self._raiseError("Unsupported Port Prototype <%s>" % tag_name)
 
@@ -1277,13 +1457,13 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = element.find("./xmlns:TRANSMISSION-ACKNOWLEDGE", self.nsmap)
         if (child_element is not None):
             acknowledge = TransmissionAcknowledgementRequest()
-            self.readElementAttributes(child_element, acknowledge)
+            self.readARObjectAttributes(child_element, acknowledge)
             acknowledge.timeout = self.getChildElementOptionalFloatValue(child_element, "TIMEOUT")
             return acknowledge
         return None
 
     def readSenderComSpec(self, element:ET.Element, com_spec: SenderComSpec):
-        self.readElementAttributes(element, com_spec)
+        self.readARObjectAttributes(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.setDataElementRef(self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")) \
@@ -1300,6 +1480,7 @@ class ARXMLParser(AbstractARXMLParser):
     
     def getServerComSpec(self, element) -> ServerComSpec:
         com_spec = ServerComSpec()
+        self.readARObjectAttributes(element, com_spec)
         com_spec.setOperationRef(self.getChildElementOptionalRefType(element, "OPERATION-REF")) \
                 .setQueueLength(self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH"))
         return com_spec
@@ -1329,15 +1510,6 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
 
-    def readPPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
-        short_name = self.getShortName(element)
-        self.logger.debug("readPPortPrototype %s" % short_name)
-        prototype = parent.createPPortPrototype(short_name)
-        self.readIdentifiable(element, prototype)
-        prototype.setProvidedInterfaceTRef(self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF"))
-
-        self.readProvidedComSpec(element, prototype)
-
     def readPortGroupInnerGroupIRefs(self, element: ET.Element, parent: PortGroup):
         for child_element in self.findall(element, "INNER-GROUP-IREFS/INNER-GROUP-IREF"):
             inner_group_iref = InnerPortGroupInCompositionInstanceRef()
@@ -1426,7 +1598,7 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, "PROVIDER-IREF")
         if (child_element is not None):
             provide_iref = PPortInCompositionInstanceRef()
-            self.readElementAttributes(child_element, provide_iref)
+            self.readARObjectAttributes(child_element, provide_iref)
             self.readPPortInCompositionInstanceRef(child_element, provide_iref)
             parent.setProviderIRef(provide_iref)
 
@@ -1434,7 +1606,7 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, "REQUESTER-IREF")
         if (child_element is not None):
             requester_iref = RPortInCompositionInstanceRef()
-            self.readElementAttributes(child_element, requester_iref)
+            self.readARObjectAttributes(child_element, requester_iref)
             self.readRPortInCompositionInstanceRef(child_element, requester_iref)
             parent.setRequesterIRef(requester_iref)
 
@@ -1515,9 +1687,9 @@ class ARXMLParser(AbstractARXMLParser):
     def readDataTypeMaps(self, element: ET.Element, parent: DataTypeMappingSet):
         for child_element in element.findall("./xmlns:DATA-TYPE-MAPS/xmlns:DATA-TYPE-MAP", self.nsmap):
             data_type_map = DataTypeMap()
-            self.readElementAttributes(child_element, data_type_map)
-            data_type_map.application_data_type_ref = self.getChildElementOptionalRefType(child_element, "APPLICATION-DATA-TYPE-REF")
-            data_type_map.implementation_data_type_ref = self.getChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
+            self.readARObjectAttributes(child_element, data_type_map)
+            data_type_map.applicationDataTypeRef = self.getChildElementOptionalRefType(child_element, "APPLICATION-DATA-TYPE-REF")
+            data_type_map.implementationDataTypeRef = self.getChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
             parent.addDataTypeMap(data_type_map)
             # add the data type map to global namespace
             AUTOSAR.getInstance().addDataTypeMap(data_type_map)
@@ -1525,9 +1697,9 @@ class ARXMLParser(AbstractARXMLParser):
     def readModeRequestTypeMaps(self, element: ET.Element, parent: DataTypeMappingSet):
         for child_element in element.findall("./xmlns:MODE-REQUEST-TYPE-MAPS/xmlns:MODE-REQUEST-TYPE-MAP", self.nsmap):
             map = ModeRequestTypeMap()
-            self.readElementAttributes(child_element, map)
-            map.implementation_data_type_ref = self.getChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
-            map.mode_group_ref = self.getChildElementOptionalRefType(child_element, "MODE-GROUP-REF")
+            self.readARObjectAttributes(child_element, map)
+            map.implementationDataTypeRef = self.getChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
+            map.modeGroupRef = self.getChildElementOptionalRefType(child_element, "MODE-GROUP-REF")
             parent.addModeRequestTypeMap(map)
 
     def readDataTypeMappingSet(self, element: ET.Element, parent: ARPackage):
@@ -1538,7 +1710,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readModeRequestTypeMaps(element, mapping_set)
 
     def readSenderReceiverInterfaceDataElements(self, element: ET.Element, sr_interface: SenderReceiverInterface):
-        for child_element in element.findall("./xmlns:DATA-ELEMENTS/xmlns:VARIABLE-DATA-PROTOTYPE", self.nsmap):
+        for child_element in self.findall(element, "DATA-ELEMENTS/VARIABLE-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = sr_interface.createDataElement(short_name)
             self.readIdentifiable(child_element, prototype)
@@ -1554,7 +1726,7 @@ class ARXMLParser(AbstractARXMLParser):
             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):
+        for child_element in self.findall(element, "INVALIDATION-POLICYS/INVALIDATION-POLICY"):
             # short_name = self.getShortName(child_element)
             policy = parent.createInvalidationPolicy()
             self.readIdentifiable(child_element, policy)
@@ -1570,7 +1742,7 @@ class ARXMLParser(AbstractARXMLParser):
         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):
+        for child_element in self.findall(element, "ARGUMENTS/ARGUMENT-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
             prototype = ArgumentDataPrototype(property, short_name)
             self.readIdentifiable(child_element, prototype)
@@ -1581,13 +1753,13 @@ class ARXMLParser(AbstractARXMLParser):
             parent.addArgumentDataPrototype(prototype)
 
     def readPossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
-        child_element = element.find("./xmlns:POSSIBLE-ERROR-REFS", self.nsmap)
+        child_element = self.find(element, "POSSIBLE-ERROR-REFS")
         if child_element is not None:
-            for ref in self.getChildElementRefTypeList(child_element, "./POSSIBLE-ERROR-REF"):
+            for ref in self.getChildElementRefTypeList(child_element, "POSSIBLE-ERROR-REF"):
                 parent.addPossibleErrorRef(ref)
 
     def readOperations(self, element: ET.Element, parent: ClientServerInterface):
-        for child_element in element.findall("./xmlns:OPERATIONS/xmlns:CLIENT-SERVER-OPERATION", self.nsmap):
+        for child_element in self.findall(element, "OPERATIONS/CLIENT-SERVER-OPERATION"):
             short_name = self.getShortName(child_element)
             operation = parent.createOperation(short_name)
             self.readIdentifiable(child_element, operation)
@@ -1595,82 +1767,109 @@ class ARXMLParser(AbstractARXMLParser):
             self.readPossibleErrorRefs(child_element, operation)
 
     def readPossibleErrors(self, element: ET.Element, parent: ClientServerInterface):
-        for child_element in element.findall("./xmlns:POSSIBLE-ERRORS/xmlns:APPLICATION-ERROR", self.nsmap):
+        for child_element in self.findall(element, "POSSIBLE-ERRORS/APPLICATION-ERROR"):
             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):
+        self.readIdentifiable(element, port_interface)
         port_interface.isService = self.getChildElementOptionalBooleanValue(element, "IS-SERVICE")
         port_interface.serviceKind = self.getChildElementOptionalLiteral(element, "SERVICE-KIND")
 
+    def readParameterInterfaceParameters(self, element: ET.Element, param_interface: ParameterInterface):
+        for child_element in self.findall(element, "PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
+            short_name = self.getShortName(child_element)
+            prototype = param_interface.createParameter(short_name)
+            self.readParameterDataPrototype(child_element, prototype)
+    
+    def readParameterInterface(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read ParameterInterface %s" % short_name)
+        param_interface = parent.createParameterInterface(short_name)
+        self.readPortInterface(element, param_interface)
+        self.readParameterInterfaceParameters(element, param_interface)
+
     def readClientServerInterface(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         cs_interface = parent.createClientServerInterface(short_name)
-        self.readIdentifiable(element, cs_interface)
         self.readPortInterface(element, cs_interface)
         self.readOperations(element, cs_interface)
         self.readPossibleErrors(element, cs_interface)
 
     def readCompuConst(self, element: ET.Element, parent: CompuScale):
-        child_element = element.find("./xmlns:COMPU-CONST/xmlns:VT", self.nsmap)
+        child_element = self.find(element, "COMPU-CONST/VT")
         if (child_element is not None):
             self.logger.debug("readCompuConst VT: %s" % child_element.text)
             contents = CompuScaleConstantContents()
-            contents.compu_const = CompuConst()
-            contents.compu_const.compu_const_content_type = CompuConstTextContent()
-            contents.compu_const.compu_const_content_type.vt = ARLiteral()
-            contents.compu_const.compu_const_content_type.vt.setValue(child_element.text)
+            contents.compuConst = CompuConst()
+            contents.compuConst.compuConstContentType = CompuConstTextContent()
+            contents.compuConst.compuConstContentType.vt = ARLiteral()
+            contents.compuConst.compuConstContentType.vt.setValue(child_element.text)
             parent.compuScaleContents = contents
 
     def readCompuNominatorDenominator(self, element: ET.Element, key: str, parent: CompuNominatorDenominator):
-        for child_element in element.findall("./xmlns:%s/xmlns:V" % key, self.nsmap):
+        for child_element in self.findall(element, "%s/V" % key):
             self.logger.debug("readCompuNominatorDenominator - %s: %s" % (key, child_element.text))
             parent.add_v(child_element.text)
 
     def readCompuRationCoeffs(self, element: ET.Element, parent: CompuScale):
-        child_element = element.find("./xmlns:COMPU-RATIONAL-COEFFS", self.nsmap)
+        child_element = self.find(element, "COMPU-RATIONAL-COEFFS")
         if (child_element is not None):
             self.logger.debug("readCompuRationCoeffs")
             contents = CompuScaleRationalFormula()
-            contents.compu_rational_coeffs = CompuRationalCoeffs()
-            contents.compu_rational_coeffs.compu_denominator = CompuNominatorDenominator()
-            contents.compu_rational_coeffs.compu_numerator = CompuNominatorDenominator()
-            self.readCompuNominatorDenominator(child_element, "COMPU-DENOMINATOR", contents.compu_rational_coeffs.compu_denominator)
-            self.readCompuNominatorDenominator(child_element, "COMPU-NUMERATOR", contents.compu_rational_coeffs.compu_numerator)
+            contents.compuRationalCoeffs = CompuRationalCoeffs()
+            contents.compuRationalCoeffs.compuDenominator = CompuNominatorDenominator()
+            contents.compuRationalCoeffs.compuNumerator = CompuNominatorDenominator()
+            self.readCompuNominatorDenominator(child_element, "COMPU-DENOMINATOR", contents.compuRationalCoeffs.compuDenominator)
+            self.readCompuNominatorDenominator(child_element, "COMPU-NUMERATOR", contents.compuRationalCoeffs.compuNumerator)
             parent.compuScaleContents = contents
 
     def readCompuScaleContents(self, element: ET.Element, parent: CompuScale):
         self.readCompuConst(element, parent)
         self.readCompuRationCoeffs(element, parent)
 
-    def readCompuScales(self, element: ET.Element, parent: CompuScales):
-        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")
-            self.readCompuScaleContents(child_element, compu_scale)
-            parent.addCompuScale(compu_scale)
-
-    def readCompuInternalToPhys(self, element: ET.Element, parent: CompuMethod):
-        child_element = element.find("./xmlns:COMPU-INTERNAL-TO-PHYS", self.nsmap)
+    def getCompuScales(self, element: ET.Element) -> CompuScales:
+        compu_scales = None
+        compu_scales_tag = self.find(element, "COMPU-SCALES")
+        if compu_scales_tag is not None:
+            compu_scales = CompuScales()
+            for child_element in self.findall(compu_scales_tag, 'COMPU-SCALE'):
+                compu_scale = CompuScale()
+                self.readARObjectAttributes(child_element, compu_scale)
+                compu_scale.setLowerLimit(self.getChildLimitElement(child_element, "LOWER-LIMIT")) \
+                           .setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
+                           .setSymbol(self.getChildElementOptionalLiteral(child_element, "SYMBOL")) \
+                           .setUpperLimit(self.getChildLimitElement(child_element, "UPPER-LIMIT"))
+                self.readCompuScaleContents(child_element, compu_scale)
+                compu_scales.addCompuScale(compu_scale)
+        return compu_scales
+
+    def readCompuInternalToPhys(self, element: ET.Element, compu_method: CompuMethod):
+        child_element = self.find(element, "COMPU-INTERNAL-TO-PHYS")
+        if (child_element is not None):
+            compu = Compu()
+            self.readARObjectAttributes(child_element, compu)
+            compu.setCompuContent(self.getCompuScales(child_element))
+            compu_method.setCompuInternalToPhys(compu)
+
+    def readCompuPhysToInternal(self, element: ET.Element, compu_method: CompuMethod):
+        child_element = self.find(element, "COMPU-PHYS-TO-INTERNAL")
         if (child_element is not None):
-            parent.compu_internal_to_phys = Compu()
-            self.readElementAttributes(child_element, parent.compu_internal_to_phys)
-            parent.compu_internal_to_phys.compu_content = CompuScales()
-            self.readCompuScales(child_element, parent.compu_internal_to_phys.compu_content)
+            compu = Compu()
+            self.readARObjectAttributes(child_element, compu)
+            compu.setCompuContent(self.getCompuScales(child_element))
+            compu_method.setCompuPhysToInternal(compu)
 
     def readCompuMethod(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         self.logger.debug("readCompuMethods %s" % short_name)
         compu_method = parent.createCompuMethod(short_name)
         self.readIdentifiable(element, compu_method)
-        compu_method.unit_ref = self.getChildElementOptionalRefType(element, "UNIT-REF")
+        compu_method.setUnitRef(self.getChildElementOptionalRefType(element, "UNIT-REF"))
         self.readCompuInternalToPhys(element, compu_method)
+        self.readCompuPhysToInternal(element, compu_method)
 
     def readSwcBswRunnableMappings(self, element: ET.Element, parent: SwcBswMapping):
         for child_element in element.findall("./xmlns:RUNNABLE-MAPPINGS/xmlns:SWC-BSW-RUNNABLE-MAPPING", self.nsmap):
@@ -1688,30 +1887,33 @@ class ARXMLParser(AbstractARXMLParser):
         swc_bsw_mapping.swcBehaviorRef = self.getChildElementOptionalRefType(element, "SWC-BEHAVIOR-REF")
 
     def readValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
-        self.readElementAttributes(element, value_spec)
-        value_spec.short_label = self.getChildElementOptionalLiteral(element, "SHORT-LABEL")
+        self.readARObjectAttributes(element, value_spec)
+        value_spec.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL"))
         self.logger.debug("readValueSpecification")
 
     def getApplicationValueSpecification(self, element: ET.Element) -> ApplicationValueSpecification:
         self.logger.debug("getApplicationValueSpecification")
         value_spec = ApplicationValueSpecification()
         self.readValueSpecification(element, value_spec)
-        value_spec.category = self.getChildElementOptionalLiteral(element, "CATEGORY")
-        value_spec.sw_value_cont = self.getSwValueCont(element)
+        value_spec.setCategory(self.getChildElementOptionalLiteral(element, "CATEGORY")) \
+                  .setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
+                  .setSwValueCont(self.getSwValueCont(element))
         return value_spec
     
     def getNumericalValueSpecification(self, element: ET.Element) -> NumericalValueSpecification:
         self.logger.debug("getNumericalValueSpecification")
         value_spec = NumericalValueSpecification()
         self.readValueSpecification(element, value_spec)
-        value_spec.value = self.getChildElementOptionalFloatValue(element, "VALUE")
+        value_spec.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
+                  .setValue(self.getChildElementOptionalFloatValue(element, "VALUE"))
         return value_spec
     
     def getTextValueSpecification(self, element: ET.Element) -> TextValueSpecification:
         self.logger.debug("getTextValueSpecification")
         value_spec = TextValueSpecification()
         self.readValueSpecification(element, value_spec)
-        value_spec.value = self.getChildElementOptionalLiteral(element, "VALUE")
+        value_spec.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
+                  .setValue(self.getChildElementOptionalLiteral(element, "VALUE"))
         return value_spec
 
     def getArrayValueSpecification(self, element: ET.Element) -> ArrayValueSpecification:
@@ -1745,7 +1947,7 @@ class ARXMLParser(AbstractARXMLParser):
         elif tag_name == "CONSTANT-REFERENCE":
             value_spec = self.getConstantReference(element)
         else:
-            raise NotImplementedError("Unsupported RecordValueSpecificationField %s" % tag_name)
+            self.notImplemented("Unsupported RecordValueSpecificationField %s" % tag_name)
         return value_spec
 
     def readRecordValueSpecificationFields(self, element: ET.Element, spec: RecordValueSpecification):
@@ -1770,7 +1972,7 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = element.find("./xmlns:INTERNAL-CONSTRS", self.nsmap)
         if child_element is not None:
             constrs = InternalConstrs()
-            self.readElementAttributes(child_element, constrs)
+            self.readARObjectAttributes(child_element, constrs)
             constrs.lower_limit = self.getChildLimitElement(child_element, "LOWER-LIMIT")
             constrs.upper_limit = self.getChildLimitElement(child_element, "UPPER-LIMIT")
             parent.internalConstrs = constrs
@@ -1779,7 +1981,7 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = element.find("./xmlns:PHYS-CONSTRS", self.nsmap)
         if child_element is not None:
             constrs = PhysConstrs()
-            self.readElementAttributes(child_element, constrs)
+            self.readARObjectAttributes(child_element, constrs)
             constrs.lower_limit = self.getChildLimitElement(child_element, "LOWER-LIMIT")
             constrs.upper_limit = self.getChildLimitElement(child_element, "UPPER-LIMIT")
             constrs.unit_ref = self.getChildElementOptionalRefType(child_element, "UNIT-REF")
@@ -1789,7 +1991,7 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in element.findall("./xmlns:DATA-CONSTR-RULES/xmlns:DATA-CONSTR-RULE", self.nsmap):
             self.logger.debug("readDataConstrRule")
             rule = DataConstrRule()
-            self.readElementAttributes(child_element, rule)
+            self.readARObjectAttributes(child_element, rule)
             rule.constrLevel = self.getChildElementOptionalNumericalValue(child_element, "CONSTR-LEVEL")
             self.readInternalConstrs(child_element, rule)
             self.readPhysConstrs(child_element, rule)
@@ -1905,6 +2107,7 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readDataPrototype(self, element: ET.Element, prototype: DataPrototype):
         self.readIdentifiable(element, prototype)
+        prototype.setSwDataDefProps(self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS"))
 
     def readApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
         self.readDataPrototype(element, prototype)
@@ -1949,6 +2152,7 @@ class ARXMLParser(AbstractARXMLParser):
                  .setSwRecordLayoutGroupAxis(self.getChildElementOptionalNumericalValue(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS")) \
                  .setSwRecordLayoutGroupIndex(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-INDEX")) \
                  .setSwRecordLayoutGroupFrom(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-FROM")) \
+                 .setSwRecordLayoutGroupStep(self.getChildElementOptionalIntegerValue(child_element, "SW-RECORD-LAYOUT-GROUP-STEP")) \
                  .setSwRecordLayoutGroupTo(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO")) \
             
             group_content = SwRecordLayoutGroupContent()
@@ -1971,8 +2175,14 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readSwAddrMethod(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
-        self.logger.debug("readSwAddrMethod %s" % short_name)
-        layout = parent.createSwAddrMethod(short_name)
+        self.logger.debug("read SwAddrMethod %s" % short_name)
+        method = parent.createSwAddrMethod(short_name)
+        self.readIdentifiable(element, method)
+        method.setMemoryAllocationKeywordPolicy(self.getChildElementOptionalLiteral(element, "MEMORY-ALLOCATION-KEYWORD-POLICY")) 
+        for option in self.getChildElementLiteralValueList(element, "OPTIONS/OPTION"):
+            method.addOption(option)
+        method.setSectionInitializationPolicy(self.getChildElementOptionalLiteral(element, "SECTION-INITIALIZATION-POLICY")) \
+              .setSectionType(self.getChildElementOptionalLiteral(element, "SECTION-TYPE"))
 
     def readTriggerInterface(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -1980,9 +2190,10 @@ class ARXMLParser(AbstractARXMLParser):
         trigger_if = parent.createTriggerInterface(short_name)
 
     def readModeDeclarationGroupModeDeclaration(self, element: ET.Element, parent: ModeDeclarationGroup):
-        for child_element in element.findall("./xmlns:MODE-DECLARATIONS/xmlns:MODE-DECLARATION", self.nsmap):
+        for child_element in self.findall(element, "MODE-DECLARATIONS/MODE-DECLARATION"):
             short_name = self.getShortName(child_element)
             declaration = parent.createModeDeclaration(short_name)
+            self.readARObjectAttributes(child_element, declaration)
             declaration.setValue(self.getChildElementOptionalNumericalValue(child_element, "VALUE"))
 
     def readModeDeclarationGroup(self, element: ET.Element, parent: ARPackage):
@@ -2103,7 +2314,7 @@ class ARXMLParser(AbstractARXMLParser):
                 triggering = channel.createLinFrameTriggering(self.getShortName(child_element))
                 self.readLinFrameTriggering(child_element, triggering)
             else:
-                raise NotImplementedError("Unsupported Frame Triggering <%s>" % tag_name)
+                self.notImplemented("Unsupported Frame Triggering <%s>" % tag_name)
             
         for child_element in self.findall(element, "I-SIGNAL-TRIGGERINGS/*"):
             tag_name = self.getTagName(child_element)
@@ -2111,7 +2322,7 @@ class ARXMLParser(AbstractARXMLParser):
                 triggering = channel.createISignalTriggering(self.getShortName(child_element))
                 self.readISignalTriggering(child_element, triggering)
             else:
-                raise NotImplementedError("Unsupported Frame Triggering <%s>" % tag_name)
+                self.notImplemented("Unsupported Frame Triggering <%s>" % tag_name)
             
         for child_element in self.findall(element, "PDU-TRIGGERINGS/*"):
             tag_name = self.getTagName(child_element)
@@ -2119,7 +2330,7 @@ class ARXMLParser(AbstractARXMLParser):
                 triggering = channel.createPduTriggering(self.getShortName(child_element))
                 self.readPduTriggering(child_element, triggering)
             else:
-                raise NotImplementedError("Unsupported Frame Triggering <%s>" % tag_name)
+                self.notImplemented("Unsupported Frame Triggering <%s>" % tag_name)
 
     def readCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
         self.readIdentifiable(element, channel)
@@ -2139,7 +2350,7 @@ class ARXMLParser(AbstractARXMLParser):
                 channel = cluster.createLinPhysicalChannel(self.getShortName(child_element))
                 self.readLinPhysicalChannel(child_element, channel)
             else:
-                raise NotImplementedError("Unsupported Physical Channel <%s>" % tag_name)
+                self.notImplemented("Unsupported Physical Channel <%s>" % tag_name)
 
 
     def readCommunicationCluster(self, element: ET.Element, cluster: CommunicationCluster):
@@ -2450,11 +2661,11 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("ISignal %s" % short_name)
         signal = parent.createISignal(short_name)
         self.readIdentifiable(element, signal)
-        signal.dataTypePolicy = self.getChildElementOptionalLiteral(element, "DATA-TYPE-POLICY")
-        signal.initValue = self.getInitValue(element)
-        signal.length = self.getChildElementOptionalNumericalValue(element, "LENGTH")
-        signal.networkRepresentationProps = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION-PROPS")
-        signal.systemSignalRef = self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-REF")
+        signal.setDataTypePolicy(self.getChildElementOptionalLiteral(element, "DATA-TYPE-POLICY")) \
+              .setInitValue(self.getInitValue(element)) \
+              .setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH")) \
+              .setNetworkRepresentationProps(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION-PROPS")) \
+              .setSystemSignalRef(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"):
@@ -2496,7 +2707,7 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "ECUC-NUMERICAL-PARAM-VALUE":
                 container_value.addParameterValue(self.getEcucNumericalParamValue(child_element))
             else:
-                raise NotImplementedError("Unsupported EcucParameterValue <%s>" % tag_name)
+                self.notImplemented("Unsupported EcucParameterValue <%s>" % tag_name)
             
     def readEcucAbstractReferenceValue(self, element: ET.Element, value: EcucAbstractReferenceValue):
         value.setDefinitionRef(self.getChildElementOptionalRefType(element, "DEFINITION-REF"))
@@ -2533,7 +2744,7 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "ECUC-INSTANCE-REFERENCE-VALUE":
                 container_value.addReferenceValue(self.getEcucInstanceReferenceValue(child_element))
             else:
-                raise NotImplementedError("Unsupported EcucParameterValue <%s>" % tag_name)
+                self.notImplemented("Unsupported EcucParameterValue <%s>" % tag_name)
 
     def readEcucContainerValue(self, element: ET.Element, container_value: EcucContainerValue):
         self.readIdentifiable(element, container_value)
@@ -2554,7 +2765,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "ECUC-CONTAINER-VALUE":
                 self.readEcucContainerValueEcucContainerValue(child_element, parent)
             else:
-                raise NotImplementedError("Unsupported Sub Container %s" % tag_name) 
+                self.notImplemented("Unsupported Sub Container %s" % tag_name) 
 
     def readEcucModuleConfigurationValuesEcucContainerValue(self, element: ET.Element, parent: EcucModuleConfigurationValues):
         short_name = self.getShortName(element)
@@ -2568,7 +2779,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "ECUC-CONTAINER-VALUE":
                 self.readEcucModuleConfigurationValuesEcucContainerValue(child_element, values)
             else:
-                raise NotImplementedError("Unsupported Container %s" % tag_name) 
+                self.notImplemented("Unsupported Container %s" % tag_name) 
 
     def readEcucModuleConfigurationValues(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -2582,11 +2793,12 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readPhysicalDimensions(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
-        self.logger.debug("readPhysicalDimensions %s" % short_name)
+        self.logger.debug("read PhysicalDimensions %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")) \
+                 .setTimeExp(self.getChildElementOptionalNumericalValue(element, "TIME-EXP"))
 
     '''
     def getIPduMappings(self, element: ET.Element) -> List[IPduMapping]:
@@ -2753,7 +2965,7 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "SENDER-RECEIVER-TO-SIGNAL-GROUP-MAPPING":
                 mapping.addDataMapping(self.getSenderReceiverToSignalGroupMapping(child_element))
             else:
-                raise NotImplementedError("Unsupported Data Mapping %s" % tag_name)
+                self.notImplemented("Unsupported Data Mapping %s" % tag_name)
 
     def readSwcToEcuMapping(self, element: ET.Element, mapping: SwcToEcuMapping):
         self.logger.debug("SwcToEcuMapping %s" % mapping.getShortName())
@@ -2768,7 +2980,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "SWC-TO-ECU-MAPPING":
                 self.readSwcToEcuMapping(child_element, mapping.createSwcToEcuMapping(self.getShortName(child_element)))
             else:
-                raise NotImplementedError("Unsupported Sw Mapping %s" % tag_name)
+                self.notImplemented("Unsupported Sw Mapping %s" % tag_name)
 
     def readSystemMapping(self, element: ET.Element, parent: System):
         short_name = self.getShortName(element)
@@ -2784,7 +2996,7 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "SYSTEM-MAPPING":
                 self.readSystemMapping(child_element, system)
             else:
-                raise NotImplementedError("Unsupported Mapping %s" % tag_name)
+                self.notImplemented("Unsupported Mapping %s" % tag_name)
             
     def readRootSwCompositionPrototype(self, element: ET.Element, system: System):
         child_element = self.find(element, "ROOT-SOFTWARE-COMPOSITIONS/ROOT-SW-COMPOSITION-PROTOTYPE")
@@ -2808,25 +3020,18 @@ class ARXMLParser(AbstractARXMLParser):
         self.readRootSwCompositionPrototype(element, system)
         system.setSystemVersion(self.getChildElementOptionalRevisionLabelString(element, "SYSTEM-VERSION"))
 
-    def readParameterInterfaceParameters(self, element: ET.Element, parent: ParameterInterface):
-        for child_element in self.findall(element, "PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
-            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("Read ParameterInterface %s" % short_name)
-        pi_interface = parent.createParameterInterface(short_name)
-        self.readIdentifiable(element, pi_interface)
-        self.readParameterInterfaceParameters(element, pi_interface)
-
     def readGenericEthernetFrame(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         self.logger.debug("Read EthernetFrame %s" % short_name)
         frame = parent.createGenericEthernetFrame(short_name)
         self.readFrame(element, frame)
 
+    def readLifeCycleInfoSet(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read LifeCycleInfoSet %s" % short_name)
+        frame = parent.createLifeCycleInfoSet(short_name)
+        self.readIdentifiable(element, frame)
+
     def readARPackageElements(self, element: ET.Element, parent: ARPackage):
         for child_element in self.findall(element, "./ELEMENTS/*"):
             tag_name = self.getTagName(child_element.tag)
@@ -2940,9 +3145,22 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readParameterInterface(child_element, parent)
             elif tag_name == "ETHERNET-FRAME":
                 self.readGenericEthernetFrame(child_element, parent)
+            elif tag_name == "LIFE-CYCLE-INFO-SET":
+                self.readLifeCycleInfoSet(child_element, parent)
             else:
                 self._raiseError("Unsupported element type of ARPackage <%s>" % tag_name)
 
+    def readReferenceBases(self, element: ET.Element, parent: ARPackage):
+        self.logger.debug("Read ReferenceBases")
+        for child_element in self.findall(element, "REFERENCE-BASES/REFERENCE-BASE"):
+            base = ReferenceBase()
+            base.setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
+                .setIsDefault(self.getChildElementOptionalBooleanValue(child_element, "IS-DEFAULT")) \
+                .setIsGlobal(self.getChildElementOptionalBooleanValue(child_element, "IS-GLOBAL")) \
+                .setBaseIsThisPackage(self.getChildElementOptionalBooleanValue(child_element, "BASE-IS-THIS-PACKAGE")) \
+                .setPackageRef(self.getChildElementOptionalRefType(child_element, "PACKAGE-REF"))
+            parent.addReferenceBase(base)
+
     def readARPackages(self, element: ET.Element, parent: ARPackage):
         for child_element in element.findall("./xmlns:AR-PACKAGES/xmlns:AR-PACKAGE", self.nsmap):
             short_name = self.getShortName(child_element)
@@ -2951,9 +3169,9 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug("readARPackages %s" % ar_package.full_name)
 
             self.readIdentifiable(child_element, ar_package)
-            self.readARPackageElements(child_element, ar_package)
             self.readARPackages(child_element, ar_package)
-
+            self.readARPackageElements(child_element, ar_package)
+            self.readReferenceBases(child_element, ar_package)
 
     def load(self, filename, document: AUTOSAR):
         self.logger.info("Load %s ..." % os.path.realpath(filename))
@@ -2964,6 +3182,7 @@ class ARXMLParser(AbstractARXMLParser):
             self._raiseError("Invalid ARXML file <%s>" % filename)
 
         self.getAUTOSARInfo(root, document)
+        document.setAdminData(self.getAdminData(root, "ADMIN-DATA")) 
         self.readARPackages(root, document)
 
         document.reload()