armodel 1.7.8__py3-none-any.whl → 1.8.0__py3-none-any.whl

armodel/parser/arxml_parser.py

@@ -2,6 +2,8 @@ from typing import List
 import xml.etree.ElementTree as ET
 import os
 
+from armodel.models.M2.MSR.Documentation.TextModel.BlockElements.PaginationAndView import DocumentViewSelectable, Paginateable
+
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition, SwBaseType
 from ..models.M2.MSR.AsamHdo.Constraints.GlobalConstraints import DataConstrRule, InternalConstrs, PhysConstrs, DataConstr
@@ -21,20 +23,22 @@ from ..models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayoutGroup
 from ..models.M2.MSR.DataDictionary.CalibrationParameter import SwCalprmAxisSet
 from ..models.M2.MSR.DataDictionary.ServiceProcessTask import SwServiceArg
 from ..models.M2.MSR.Documentation.Annotation import Annotation, GeneralAnnotation
+from ..models.M2.MSR.Documentation.BlockElements.Figure import Graphic, LGraphic, MlFigure
 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.BlockElements.ListElements import ARList
 from ..models.M2.MSR.Documentation.TextModel.LanguageDataModel import LLongName, LOverviewParagraph, LParagraph, LanguageSpecific
 from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguageOverviewParagraph, MultiLanguageParagraph, MultiLanguagePlainText
 from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultilanguageLongName
 
 from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswApiOptions, BswBackgroundEvent, BswCalledEntity, BswDataReceivedEvent
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswOperationInvokedEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswApiOptions, BswAsynchronousServerCallPoint, BswBackgroundEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswCalledEntity, BswDataReceivedEvent, BswModuleCallPoint
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalTriggeringPoint, BswOperationInvokedEvent
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswDataReceptionPolicy, BswExternalTriggerOccurredEvent, BswInternalBehavior
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswInternalTriggerOccurredEvent, BswInterruptEntity, BswModeSwitchEvent
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswModuleEntity, BswQueuedDataReceptionPolicy, BswSchedulableEntity
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswScheduleEvent, BswModeSenderPolicy, BswTimingEvent, BswVariableAccess
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleEntry
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleClientServerEntry, BswModuleEntry
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswImplementation import BswImplementation
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswOverview import BswModuleDescription
 from ..models.M2.AUTOSARTemplates.CommonStructure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference
@@ -49,11 +53,14 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import Res
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.MemorySectionUsage import MemorySection
 from ..models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.StackUsage import RoughEstimateStackUsage, StackUsage
 from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping, SwcBswRunnableMapping
-from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal, DltUserNeeds, ServiceNeeds
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticCapabilityElement, DtcStatusChangeNotificationNeeds
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import EcuStateMgrUserNeeds, NvBlockNeeds, RoleBasedDataAssignment
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import RoleBasedDataTypeAssignment, ServiceDependency
+from ..models.M2.AUTOSARTemplates.CommonStructure.StandardizationTemplate.BlueprintDedicated.PortPrototypeBlueprint import PortPrototypeBlueprint
+from ..models.M2.AUTOSARTemplates.CommonStructure.StandardizationTemplate.Keyword import Keyword, KeywordSet
 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
@@ -66,12 +73,13 @@ from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucReferenceVa
 from ..models.M2.AUTOSARTemplates.EcuResourceTemplate import HwDescriptionEntity, HwElement, HwPinGroup
 from ..models.M2.AUTOSARTemplates.EcuResourceTemplate.HwElementCategory import HwAttributeDef, HwCategory, HwType
 from ..models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstanceRef
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ElementCollection import Collection
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Describable, Identifiable
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Referrable, MultilanguageReferrable
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject, EngineeringObject
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage, ReferenceBase
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType, ARLiteral
-from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfoSet
+from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfo, LifeCycleInfoSet, LifeCyclePeriod
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationPrimitiveDataType, ApplicationRecordDataType
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationCompositeDataType
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationDataType, AutosarDataType, DataTypeMap, DataTypeMappingSet
@@ -103,7 +111,8 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import Assembl
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationCompositeElementDataPrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ApplicationRecordElement, AutosarDataPrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import DataPrototype, ParameterDataPrototype, VariableDataPrototype
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ArgumentDataPrototype, ClientServerInterface, ClientServerOperation
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ArgumentDataPrototype, ClientServerInterface, ClientServerInterfaceMapping
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ClientServerOperation, ClientServerOperationMapping
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import DataPrototypeMapping, InvalidationPolicy, ModeSwitchInterface
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import ParameterInterface, PortInterface, PortInterfaceMappingSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface import SenderReceiverInterface, TriggerInterface, DataInterface
@@ -358,7 +367,7 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in self.findall(element, "%s/VARIABLE-ACCESS" % key):
             short_name = self.getShortName(child_element)
 
-            self.logger.debug("readVariableAccesses %s" % short_name)
+            # self.logger.debug("Read VariableAccesses %s" % short_name)
 
             if (key == "DATA-RECEIVE-POINT-BY-ARGUMENTS"):
                 variable_access = parent.createDataReceivePointByArgument(short_name)
@@ -391,7 +400,7 @@ class ARXMLParser(AbstractARXMLParser):
             ref = self.getChildElementOptionalRefType(child_element, "BSW-MODULE-ENTRY-REF")
             if (ref is not None):
                 parent.addImplementedEntryRef(ref)
-            self.logger.debug("ImplementedEntry <%s> of BswModuleDescription <%s> has been added", ref.value, parent.getShortName())
+            # self.logger.debug("ImplementedEntry <%s> of BswModuleDescription <%s> has been added", ref.value, parent.getShortName())
 
     def readModeDeclarationGroupPrototype(self, element: ET.Element, prototype: ModeDeclarationGroupPrototype):
         self.readIdentifiable(element, prototype)
@@ -420,7 +429,7 @@ class ARXMLParser(AbstractARXMLParser):
             entity.addCanEnterExclusiveAreaRef(ref)
 
     def readExecutableEntity(self, element: ET.Element, entity: ExecutableEntity):
-        self.logger.debug("readExecutableEntity %s" % entity.getShortName())
+        # self.logger.debug("Read ExecutableEntity %s" % entity.getShortName())
         self.readIdentifiable(element, entity)
         self.readCanEnterExclusiveAreaRefs(element, entity)
         entity.setMinimumStartInterval(self.getChildElementOptionalFloatValue(element, "MINIMUM-START-INTERVAL")) \
@@ -439,7 +448,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readBswEvent(element, event)
 
     def readBswModeSwitchEvent(self, element: ET.Element, event: BswModeSwitchEvent):
-        self.logger.debug("Read BswModeSwitchEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read BswModeSwitchEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
 
@@ -454,13 +463,13 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug(" Period: <%f, %s>" % (event.getPeriod().getValue(), event.getPeriod().getText()))
 
     def readBswDataReceivedEvent(self, element: ET.Element, event: BswDataReceivedEvent):
-        self.logger.debug("Read BswDataReceivedEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read BswDataReceivedEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
         event.setDataRef(self.getChildElementOptionalRefType(element, "DATA-REF"))
 
     def readBswInternalTriggerOccurredEvent(self, element: ET.Element, event: BswInternalTriggerOccurredEvent):
-        self.logger.debug("Read BswInternalTriggerOccurredEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read BswInternalTriggerOccurredEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
         event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
@@ -557,9 +566,12 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.raiseError("Unsupported assigned ports <%s>" % tag_name)
 
-    def readNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
-        self.logger.debug("Read NvBlockNeeds <%s>" % needs.getShortName())
+    def readServiceNeeds(self, element: ET.Element, needs: ServiceNeeds):
         self.readIdentifiable(element, needs)
+
+    def readNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
+        # self.logger.debug("Read NvBlockNeeds <%s>" % needs.getShortName())
+        self.readServiceNeeds(element, needs)
         needs.setCalcRamBlockCrc(self.getChildElementOptionalBooleanValue(element, "CALC-RAM-BLOCK-CRC")) \
              .setCheckStaticBlockId(self.getChildElementOptionalBooleanValue(element, "CHECK-STATIC-BLOCK-ID")) \
              .setNDataSets(self.getChildElementOptionalNumericalValue(element, "N-DATA-SETS")) \
@@ -580,20 +592,23 @@ class ARXMLParser(AbstractARXMLParser):
              .setWritingFrequency(self.getChildElementOptionalPositiveInteger(element, "WRITING-FREQUENCY")) \
              .setWritingPriority(self.getChildElementOptionalLiteral(element, "WRITING-PRIORITY"))
         
-    def reaDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
-        self.logger.debug("Read DiagnosticCommunicationManagerNeeds <%s>" % needs.getShortName())
-        self.readIdentifiable(element, needs)
+    def readDiagnosticCapabilityElement(self, element: ET.Element, needs: DiagnosticCapabilityElement):
+        self.readServiceNeeds(element, needs)
+        
+    def readDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
+        # self.logger.debug("Read DiagnosticCommunicationManagerNeeds <%s>" % needs.getShortName())
+        self.readDiagnosticCapabilityElement(element, needs)
         needs.setServiceRequestCallbackType(self.getChildElementOptionalLiteral(element, "SERVICE-REQUEST-CALLBACK-TYPE"))
 
     def readDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
-        self.logger.debug("Read DiagnosticRoutineNeeds %s" % needs.getShortName())
-        self.readIdentifiable(element, needs)
+        # self.logger.debug("Read DiagnosticRoutineNeeds %s" % needs.getShortName())
+        self.readDiagnosticCapabilityElement(element, needs)
         needs.setDiagRoutineType(self.getChildElementOptionalLiteral(element, "DIAG-ROUTINE-TYPE")) \
              .setRidNumber(self.getChildElementOptionalIntegerValue(element, "RID-NUMBER"))
 
     def readDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
-        self.logger.debug("Read DiagnosticValueNeeds %s" % needs.getShortName())
-        self.readIdentifiable(element, needs)
+        # self.logger.debug("Read DiagnosticValueNeeds %s" % needs.getShortName())
+        self.readDiagnosticCapabilityElement(element, needs)
         needs.setDataLength(self.getChildElementOptionalPositiveInteger(element, "DATA-LENGTH")) \
              .setDiagnosticValueAccess(self.getChildElementOptionalLiteral(element, "DIAGNOSTIC-VALUE-ACCESS")) \
              .setDidNumber(self.getChildElementOptionalIntegerValue(element, "DID-NUMBER")) \
@@ -601,7 +616,7 @@ class ARXMLParser(AbstractARXMLParser):
              .setProcessingStyle(self.getChildElementOptionalLiteral(element, "PROCESSING-STYLE"))
         
     def readDiagEventDebounceMonitorInternal(self, element: ET.Element, algorithm: DiagEventDebounceMonitorInternal):
-        self.readIdentifiable(element, algorithm)
+        self.readDiagnosticCapabilityElement(element, algorithm)
         
     def readDiagEventDebounceAlgorithm(self, element: ET.Element, needs: DiagnosticEventNeeds):
         for child_element in self.findall(element, "DIAG-EVENT-DEBOUNCE-ALGORITHM/*"):
@@ -613,25 +628,35 @@ class ARXMLParser(AbstractARXMLParser):
                 self.notImplemented("Unsupported DiagEventDebounceAlgorithm <%s>" % tag_name)
     
     def readDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
-        self.logger.debug("Read DiagnosticEventNeeds <%s>" % needs.getShortName())
-        self.readIdentifiable(element, needs)
+        # self.logger.debug("Read DiagnosticEventNeeds <%s>" % needs.getShortName())
+        self.readDiagnosticCapabilityElement(element, needs)
         self.readDiagEventDebounceAlgorithm(element, needs)
         needs.setDtcKind(self.getChildElementOptionalLiteral(element, "DTC-KIND")) \
              .setUdsDtcNumber(self.getChildElementOptionalIntegerValue(element, "UDS-DTC-NUMBER"))
         
     def readDiagnosticEventInfoNeeds(self, element: ET.Element, needs: DiagnosticEventInfoNeeds):
-        self.logger.debug("Read DiagnosticEventInfoNeeds <%s>" % needs.getShortName())
-        self.readIdentifiable(element, needs)
+        # self.logger.debug("Read DiagnosticEventInfoNeeds <%s>" % needs.getShortName())
+        self.readDiagnosticCapabilityElement(element, needs)
+        needs.setDtcKind(self.getChildElementOptionalLiteral(element, "DTC-KIND"))
         needs.setUdsDtcNumber(self.getChildElementOptionalPositiveInteger(element, "UDS-DTC-NUMBER"))
 
     def readCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
-        self.logger.debug("Read CryptoServiceNeeds <%s>" % needs.getShortName())
-        self.readIdentifiable(element, needs)
+        # self.logger.debug("Read CryptoServiceNeeds <%s>" % needs.getShortName())
+        self.readServiceNeeds(element, needs)
         needs.setMaximumKeyLength(self.getChildElementOptionalPositiveInteger(element, "MAXIMUM-KEY-LENGTH"))
 
     def readEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
-        self.logger.debug("read EcuStateMgrUserNeeds %s" % needs.getShortName())
-        self.readIdentifiable(element, needs)
+        # self.logger.debug("Read EcuStateMgrUserNeeds %s" % needs.getShortName())
+        self.readServiceNeeds(element, needs)
+
+    def readDtcStatusChangeNotificationNeeds(self, element: ET.Element, needs: DtcStatusChangeNotificationNeeds):
+        # self.logger.debug("Read DtcStatusChangeNotificationNeeds %s" % needs.getShortName())
+        self.readDiagnosticCapabilityElement(element, needs)
+        needs.setDtcFormatType(self.getChildElementOptionalLiteral(element, "DTC-FORMAT-TYPE"))
+
+    def readDltUserNeeds(self, element: ET.Element, needs: DltUserNeeds):
+        # self.logger.debug("Read DltUserNeeds %s" % needs.getShortName())
+        self.readServiceNeeds(element, needs)
 
     def readSwcServiceDependencyServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         for child_element in self.findall(element, "SERVICE-NEEDS/*"):
@@ -641,7 +666,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readNvBlockNeeds(child_element, needs)
             elif tag_name == "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS":
                 needs = parent.createDiagnosticCommunicationManagerNeeds(self.getShortName(child_element))
-                self.reaDiagnosticCommunicationManagerNeeds(child_element, needs)
+                self.readDiagnosticCommunicationManagerNeeds(child_element, needs)
             elif tag_name == "DIAGNOSTIC-ROUTINE-NEEDS":
                 needs = parent.createDiagnosticRoutineNeeds(self.getShortName(child_element))
                 self.readDiagnosticRoutineNeeds(child_element, needs)
@@ -660,13 +685,19 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "ECU-STATE-MGR-USER-NEEDS":
                 needs = parent.createEcuStateMgrUserNeeds(self.getShortName(child_element))
                 self.readEcuStateMgrUserNeeds(child_element, needs)
+            elif tag_name == "DTC-STATUS-CHANGE-NOTIFICATION-NEEDS":
+                needs = parent.createDtcStatusChangeNotificationNeeds(self.getShortName(child_element))
+                self.readDtcStatusChangeNotificationNeeds(child_element, needs)
+            elif tag_name == "DLT-USER-NEEDS":
+                needs = parent.createDltUserNeeds(self.getShortName(child_element))
+                self.readDltUserNeeds(child_element, needs)
             else:
                 self.notImplemented("Unsupported service needs <%s>" % tag_name)
 
     def readSwcServiceDependency(self, element: ET.Element, parent: SwcInternalBehavior):
         short_name = self.getShortName(element)
         dependency = parent.createSwcServiceDependency(short_name)
-        self.logger.debug("read SwcServiceDependency %s" % short_name)
+        # self.logger.debug("Read SwcServiceDependency %s" % short_name)
         self.readServiceDependency(element, dependency)
         self.readSwcServiceDependencyAssignedData(element, dependency)
         self.readSwcServiceDependencyAssignedPorts(element, dependency)
@@ -778,9 +809,31 @@ class ARXMLParser(AbstractARXMLParser):
     def readBswModuleEntityIssuedTriggerRefs(self, element: ET.Element, entity: BswModuleEntity):
         for ref in self.getChildElementRefTypeList(element, "ISSUED-TRIGGERS/TRIGGER-REF-CONDITIONAL/TRIGGER-REF"):
             entity.addIssuedTriggerRef(ref)
+
+    def readBswModuleEntityActivationPointRefs(self, element: ET.Element, entity: BswModuleEntity):
+        for ref in self.getChildElementRefTypeList(element, "ACTIVATION-POINTS/BSW-INTERNAL-TRIGGERING-POINT-REF-CONDITIONAL/BSW-INTERNAL-TRIGGERING-POINT-REF"):   # noqa E501
+            entity.addActivationPointRef(ref)
+
+    def readBswModuleCallPoint(self, element: ET.Element, point: BswModuleCallPoint):
+        self.readReferrable(element, point)
+
+    def readBswAsynchronousServerCallPoint(self, element: ET.Element, point: BswAsynchronousServerCallPoint):
+        self.readBswModuleCallPoint(element, point)
+        point.setCalledEntryRef(self.getChildElementOptionalRefType(element, "CALLED-ENTRY-REF"))
+
+    def readBswModuleEntityCallPoints(self, element: ET.Element, entity: BswModuleEntity):
+        for child_element in self.findall(element, "CALL-POINTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "BSW-ASYNCHRONOUS-SERVER-CALL-POINT":
+                point = entity.createBswAsynchronousServerCallPoint(self.getShortName(child_element))
+                self.readBswAsynchronousServerCallPoint(child_element, point)
+            else:
+                self.notImplemented("Unsupported Call Point <%s>" % tag_name)
     
     def readBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
         self.readExecutableEntity(element, entity)
+        self.readBswModuleEntityActivationPointRefs(element, entity)
+        self.readBswModuleEntityCallPoints(element, entity)
         self.readBswModuleEntityDataReceiverPoints(element, entity)
         self.readBswModuleEntityDataSendPoints(element, entity)
         entity.setImplementedEntryRef(self.getChildElementRefType(entity.getShortName(), element, "IMPLEMENTED-ENTRY-REF"))
@@ -788,15 +841,15 @@ class ARXMLParser(AbstractARXMLParser):
         self.readBswModuleEntityIssuedTriggerRefs(element, entity)
     
     def readBswCalledEntity(self, element: ET.Element, entity: BswCalledEntity):
-        self.logger.debug("read BswCalledEntity %s" % entity.getShortName())
+        # self.logger.debug("Read BswCalledEntity %s" % entity.getShortName())
         self.readBswModuleEntity(element, entity)
 
     def readBswSchedulableEntity(self, element: ET.Element, entity: BswSchedulableEntity):
-        self.logger.debug("read BswSchedulableEntity %s" % entity.getShortName())
+        # self.logger.debug("Read BswSchedulableEntity %s" % entity.getShortName())
         self.readBswModuleEntity(element, entity)
 
     def readBswInterruptEntity(self, element: ET.Element, entity: BswInterruptEntity):
-        self.logger.debug("read BswSchedulableEntity %s" % entity.getShortName())
+        # self.logger.debug("Read BswSchedulableEntity %s" % entity.getShortName())
         self.readBswModuleEntity(element, entity)
         entity.setInterruptCategory(self.getChildElementOptionalLiteral(element, "INTERRUPT-CATEGORY")) \
               .setInterruptSource(self.getChildElementOptionalLiteral(element, "INTERRUPT-SOURCE"))
@@ -876,11 +929,24 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported Reception Policies <%s>" % tag_name)
 
+    def readBswInternalTriggeringPoint(self, element: ET.Element, point: BswInternalTriggeringPoint):
+        self.readIdentifiable(element, point)
+
+    def readBswInternalBehaviorInternalTriggeringPoints(self, element: ET.Element, behavior: BswInternalBehavior):
+        for child_element in self.findall(element, "INTERNAL-TRIGGERING-POINTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "BSW-INTERNAL-TRIGGERING-POINT":
+                point = behavior.createBswInternalTriggeringPoint(self.getShortName(child_element))
+                self.readBswInternalTriggeringPoint(child_element, point)
+            else:
+                self.notImplemented("Unsupported Internal Triggering Points <%s>" % tag_name)
+
     def readBswInternalBehavior(self, element: ET.Element, behavior: BswInternalBehavior):
         self.logger.debug("Read BswInternalBehavior <%s>" % behavior.full_name)
 
         # read the internal behavior
         self.readInternalBehavior(element, behavior)
+        self.readBswInternalBehaviorInternalTriggeringPoints(element, behavior)
         self.readBswInternalBehaviorEntities(element, behavior)
         self.readBswInternalBehaviorEvents(element, behavior)
         self.readBswInternalBehaviorModeSenderPolicy(element, behavior)
@@ -936,6 +1002,30 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported Required Data <%s>" % tag_name)
 
+    def readBswModuleClientServerEntry(self, element: ET.Element, entry: BswModuleClientServerEntry):
+        self.readReferrable(element, entry)
+        entry.setEncapsulatedEntryRef(self.getChildElementOptionalRefType(element, "ENCAPSULATED-ENTRY-REF")) \
+             .setIsReentrant(self.getChildElementOptionalBooleanValue(element, "IS-REENTRANT")) \
+             .setIsSynchronous(self.getChildElementOptionalBooleanValue(element, "IS-SYNCHRONOUS"))
+
+    def readBswModuleDescriptionProvidedClientServerEntries(self, element: ET.Element, desc: BswModuleDescription):
+        for child_element in self.findall(element, "PROVIDED-CLIENT-SERVER-ENTRYS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "BSW-MODULE-CLIENT-SERVER-ENTRY":
+                entry = desc.createProvidedClientServerEntry(self.getShortName(child_element))
+                self.readBswModuleClientServerEntry(child_element, entry)
+            else:
+                self.notImplemented("Unsupported Provided Client Server Entry <%s>" % tag_name)
+
+    def readBswModuleDescriptionRequiredClientServerEntries(self, element: ET.Element, desc: BswModuleDescription):
+        for child_element in self.findall(element, "REQUIRED-CLIENT-SERVER-ENTRYS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "BSW-MODULE-CLIENT-SERVER-ENTRY":
+                entry = desc.createRequiredClientServerEntry(self.getShortName(child_element))
+                self.readBswModuleClientServerEntry(child_element, entry)
+            else:
+                self.notImplemented("Unsupported Required Client Server Entry <%s>" % tag_name)
+
     def readBswModuleDescription(self, element: ET.Element, desc: BswModuleDescription):
         self.logger.debug("Read BswModuleDescription <%s>" % desc.getShortName())
 
@@ -944,11 +1034,12 @@ class ARXMLParser(AbstractARXMLParser):
         self.readBswModuleDescriptionImplementedEntryRefs(element, desc)
         self.readBswModuleDescriptionProvidedModeGroups(element, desc)
         self.readBswModuleDescriptionRequiredModeGroups(element, desc)
-        self.readBswModuleDescriptionReleasedTriggers(element, desc)
-        self.readBswModuleDescriptionRequiredTriggers(element, desc)
+        self.readBswModuleDescriptionProvidedClientServerEntries(element, desc)
+        self.readBswModuleDescriptionRequiredClientServerEntries(element, desc)
         self.readBswModuleDescriptionProvidedDatas(element, desc)
         self.readBswModuleDescriptionRequiredDatas(element, desc)
         self.readBswModuleDescriptionBswInternalBehaviors(element, desc)
+        self.readBswModuleDescriptionRequiredTriggers(element, desc)
 
     def readSwServiceArg(self, element: ET.Element, arg: SwServiceArg):
         self.readIdentifiable(element, arg)
@@ -975,8 +1066,6 @@ class ARXMLParser(AbstractARXMLParser):
              .setExecutionContext(self.getChildElementOptionalLiteral(element, "EXECUTION-CONTEXT")) \
              .setSwServiceImplPolicy(self.getChildElementOptionalLiteral(element, "SW-SERVICE-IMPL-POLICY"))
 
-        self.logger.debug("read BswModuleEntry %s" % entry.getShortName())
-
     def readEngineeringObject(self, element: ET.Element, engineering_obj: EngineeringObject):
         self.readARObjectAttributes(element, engineering_obj)
         engineering_obj.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
@@ -985,7 +1074,7 @@ class ARXMLParser(AbstractARXMLParser):
     def getAutosarEngineeringObject(self, element: ET.Element) -> AutosarEngineeringObject:
         obj = AutosarEngineeringObject()
         self.readEngineeringObject(element, obj)
-        self.logger.debug("getAutosarEngineeringObject %s", obj.short_label)
+        # self.logger.debug("Get AutosarEngineeringObject %s", obj.short_label)
         return obj
 
     def readArtifactDescriptor(self, element: ET.Element, code_desc: Code):
@@ -994,12 +1083,12 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "AUTOSAR-ENGINEERING-OBJECT":
                 code_desc.addArtifactDescriptor(self.getAutosarEngineeringObject(child_element))
             else:
-                self.raiseError("Unsupported Artifact Descriptor <%s>" % tag_name)
+                self.notImplemented("Unsupported Artifact Descriptor <%s>" % tag_name)
             
     def readCodeDescriptor(self, element: ET.Element, impl: Implementation):
         for child_element in self.findall(element, "CODE-DESCRIPTORS/CODE"):
             short_name = self.getShortName(child_element)
-            self.logger.debug("readCodeDescriptor %s" % short_name)
+            # self.logger.debug("Read CodeDescriptor %s" % short_name)
             code_desc = impl.createCodeDescriptor(short_name)
             self.readIdentifiable(child_element, code_desc)
             self.readArtifactDescriptor(child_element, code_desc)
@@ -1020,7 +1109,7 @@ class ARXMLParser(AbstractARXMLParser):
             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("read MemorySections %s" % memory_section.getShortName())
+            # self.logger.debug("read MemorySections %s" % memory_section.getShortName())
 
     def readStackUsage(self, element: ET.Element, usage: StackUsage):
         self.logger.debug("read StackUsage %s" % usage.getShortName())
@@ -1145,16 +1234,16 @@ class ARXMLParser(AbstractARXMLParser):
             parent.addModeIRef(mode_iref)
 
     def readSynchronousServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
+        # self.logger.debug("readSynchronousServerCallPoint %s" % short_name)
         short_name = self.getShortName(element)
-        self.logger.debug("readSynchronousServerCallPoint %s" % short_name)
         server_call_point = parent.createSynchronousServerCallPoint(short_name)
         self.readIdentifiable(element, server_call_point)
         server_call_point.setTimeout(self.getChildElementOptionalFloatValue(element, "TIMEOUT"))
         self.readROperationIRef(element, "OPERATION-IREF", server_call_point)
 
     def readAsynchronousServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
+        # self.logger.debug("readAsynchronousServerCallPoint %s" % short_name)
         short_name = self.getShortName(element)
-        self.logger.debug("readAsynchronousServerCallPoint %s" % short_name)
         server_call_point = parent.createAsynchronousServerCallPoint(short_name)
         self.readIdentifiable(element, server_call_point)
         server_call_point.setTimeout(self.getChildElementOptionalFloatValue(element, "TIMEOUT"))
@@ -1307,7 +1396,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.setOperationIRef(operation_iref)
 
     def readOperationInvokedEvent(self, element: ET.Element, event: OperationInvokedEvent):
-        self.logger.debug("Read OperationInvokedEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read OperationInvokedEvent <%s>" % event.getShortName())
         self.readPOperationIRef(element, "OPERATION-IREF", event)
         self.readRTEEvent(element, event)
 
@@ -1365,43 +1454,43 @@ class ARXMLParser(AbstractARXMLParser):
             behavior.addPortAPIOption(option)
             
     def readTimingEvent(self, element: ET.Element, event: TimingEvent):
-        self.logger.debug("Read TimingEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read TimingEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setOffset(self.getChildElementOptionalTimeValue(element, "OFFSET")) \
              .setPeriod(self.getChildElementOptionalTimeValue(element, "PERIOD"))
 
     def readDataReceivedEvent(self, element: ET.Element, event: DataReceivedEvent):
-        self.logger.debug("Read DataReceivedEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read DataReceivedEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         self.readRVariableInAtomicSwcInstanceRef(element, event)
 
     def readSwcModeSwitchEvent(self, element: ET.Element, event: SwcModeSwitchEvent):
-        self.logger.debug("Read SwcModeSwitchEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read SwcModeSwitchEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setActivation(self.getChildElementOptionalLiteral(element, "ACTIVATION"))
         self.readRModeInAtomicSwcInstanceRef(element, event)
 
     def readInternalTriggerOccurredEvent(self, element: ET.Element, event: InternalTriggerOccurredEvent):
-        self.logger.debug("Read InternalTriggerOccurredEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read InternalTriggerOccurredEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
     def readInitEvent(self, element, event: InitEvent):
-        self.logger.debug("Read InitEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read InitEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
 
     def readAsynchronousServerCallReturnsEvent(self, element, event: AsynchronousServerCallReturnsEvent):
-        self.logger.debug("Read AsynchronousServerCallReturnsEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read AsynchronousServerCallReturnsEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setActivationReasonRepresentationRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
     def readModeSwitchedAckEvent(self, element, event: ModeSwitchedAckEvent):
-        self.logger.debug("Read ModeSwitchedAckEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read ModeSwitchedAckEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
     def readBackgroundEvent(self, element, event: BackgroundEvent):
-        self.logger.debug("Read BackgroundEvent <%s>" % event.getShortName())
+        # self.logger.debug("Read BackgroundEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
 
     def readSwcInternalBehaviorEvents(self, element: ET.Element, parent: SwcInternalBehavior):
@@ -1486,13 +1575,13 @@ class ARXMLParser(AbstractARXMLParser):
             results.append(l1)
         return results
     
-    def getListElements(self, element: ET.Element, key: str) -> List[ListElement]:
+    def getListElements(self, element: ET.Element, key: str) -> List[ARList]:
         '''
             Read the DocumentationBlock List
         '''
         result = []
         for child_element in self.findall(element, key):
-            list = ListElement()
+            list = ARList()
             if 'TYPE' in child_element.attrib:
                 list.setType(child_element.attrib['TYPE'])
             for block in self.getDocumentationBlockList(child_element, "ITEM"):
@@ -1500,6 +1589,41 @@ class ARXMLParser(AbstractARXMLParser):
             result.append(list)
         return result
     
+    def getGraphic(self, element: ET.Element, key: str) -> Graphic:
+        graphic = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            graphic = Graphic()
+            if "FILENAME" in child_element.attrib:
+                graphic.setFilename(child_element.attrib["FILENAME"])
+        return graphic
+    
+    def readMlFigureLGraphics(self, element: ET.Element, figure: MlFigure):
+        for child_element in self.findall(element, "L-GRAPHIC"):
+            graphic = LGraphic()
+            if "L" in child_element.attrib:
+                graphic.setL(child_element.attrib["L"])
+            graphic.setGraphic(self.getGraphic(child_element, "GRAPHIC"))
+            figure.addLGraphics(graphic)
+
+    def readDocumentViewSelectable(self, element: ET.Element, selectable: DocumentViewSelectable):
+        self.readARObjectAttributes(element, selectable)
+
+    def readPaginateable(self, element: ET.Element, paginateable: Paginateable):
+        self.readDocumentViewSelectable(element, paginateable)
+    
+    def readMlFigure(self, element: ET.Element, figure: MlFigure):
+        self.readPaginateable(element, figure)
+        self.readMlFigureLGraphics(element, figure)
+
+    def getMlFigures(self, element: ET.Element, key: str) -> List[MlFigure]:
+        result = []
+        for child_element in self.findall(element, key):
+            figure = MlFigure()
+            self.readMlFigure(child_element, figure)
+            result.append(figure)
+        return result
+    
     def getMultiLanguagePlainText(self, element: ET.Element, key: str) -> MultiLanguagePlainText:
         paragraph = None
         child_element = self.find(element, key)
@@ -1509,13 +1633,15 @@ class ARXMLParser(AbstractARXMLParser):
             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)
+        for figure in self.getMlFigures(element, "FIGURE"):
+            block.addFigure(figure)
 
     def getDocumentationBlock(self, element: ET.Element, key: str) -> DocumentationBlock:
         block = None
@@ -1631,7 +1757,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readAutosarDataType(element, data_type)
 
     def readApplicationRecordElement(self, element: ET.Element, record_element: ApplicationRecordElement):
-        self.logger.debug("read ApplicationRecordElement %s" % record_element.getShortName())
+        # self.logger.debug("Read ApplicationRecordElement %s" % record_element.getShortName())
         self.readApplicationCompositeElementDataPrototype(element, record_element)
 
     def readApplicationRecordDataTypeElements(self, element: ET.Element, parent: ApplicationRecordDataType):
@@ -1690,7 +1816,7 @@ class ARXMLParser(AbstractARXMLParser):
         return iref
 
     def getCompositeNetworkRepresentation(self, element: ET.Element) -> CompositeNetworkRepresentation:
-        self.logger.debug("getCompositeNetworkRepresentation")
+        # self.logger.debug("getCompositeNetworkRepresentation")
         representation = CompositeNetworkRepresentation()
         representation.setLeafElementIRef(self.getApplicationCompositeElementInPortInterfaceInstanceRef(element, "LEAF-ELEMENT-IREF")) \
                       .setNetworkRepresentation(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION"))
@@ -1721,7 +1847,7 @@ class ARXMLParser(AbstractARXMLParser):
         value_list = None
         child_element = self.find(element, key)
         if child_element is not None:
-            self.logger.debug("getValueList %s" % key)
+            # self.logger.debug("Get ValueList %s" % key)
             value_list = ValueList()
             self.readARObjectAttributes(child_element, value_list)
             value_list.setV(self.getChildElementOptionalFloatValue(child_element, "V"))
@@ -1731,7 +1857,7 @@ class ARXMLParser(AbstractARXMLParser):
         cont = None
         child_element = self.find(element, "SW-VALUE-CONT")
         if child_element is not None:
-            self.logger.debug("getSwValueCont")
+            # self.logger.debug("Get SwValueCont")
             cont = SwValueCont()
             self.readARObjectAttributes(child_element, cont)
             cont.setUnitRef(self.getChildElementOptionalRefType(child_element, "UNIT-REF")) \
@@ -1813,7 +1939,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readProvidedComSpec(element, prototype)
 
     def readPPortPrototype(self, element: ET.Element, prototype: PPortPrototype):
-        self.logger.debug("Read PPortPrototype %s" % prototype.getShortName())
+        # self.logger.debug("Read PPortPrototype %s" % prototype.getShortName())
         self.readIdentifiable(element, prototype)
         self.readAbstractRequiredPortPrototype(element, prototype)
         prototype.setProvidedInterfaceTRef(self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF"))
@@ -1822,13 +1948,13 @@ class ARXMLParser(AbstractARXMLParser):
         self.readRequiredComSpec(element, prototype)
 
     def readRPortPrototype(self, element: ET.Element, prototype: RPortPrototype):
-        self.logger.debug("Read RPortPrototype %s" % prototype.getShortName())
+        # self.logger.debug("Read RPortPrototype %s" % prototype.getShortName())
         self.readIdentifiable(element, prototype)
         self.readAbstractProvidedPortPrototype(element, prototype)
         prototype.setRequiredInterfaceTRef(self.getChildElementOptionalRefType(element, "REQUIRED-INTERFACE-TREF"))
 
     def readPRPortPrototype(self, element: ET.Element, prototype: PRPortPrototype):
-        self.logger.debug("Read PRPortPrototype %s" % prototype.getShortName())
+        # self.logger.debug("Read PRPortPrototype %s" % prototype.getShortName())
         self.readIdentifiable(element, prototype)
         self.readAbstractRequiredPortPrototype(element, prototype)
         self.readAbstractProvidedPortPrototype(element, prototype)
@@ -1975,6 +2101,7 @@ class ARXMLParser(AbstractARXMLParser):
         p_port_in_composition_instance_ref.setContextComponentRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")) \
                                           .setTargetPPortRef(self.getChildElementOptionalRefType(element, "TARGET-P-PORT-REF"))
         
+        '''
         self.logger.debug("PPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
                           % (p_port_in_composition_instance_ref.getContextComponentRef().getDest(),
@@ -1982,11 +2109,13 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s"
                           % (p_port_in_composition_instance_ref.getTargetPPortRef().getDest(),
                              p_port_in_composition_instance_ref.getTargetPPortRef().getValue()))
+        '''
 
     def readRPortInCompositionInstanceRef(self, element, r_port_in_composition_instance_ref: RPortInCompositionInstanceRef):
         r_port_in_composition_instance_ref.setContextComponentRef(self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")) \
                                           .setTargetRPortRef(self.getChildElementOptionalRefType(element, "TARGET-R-PORT-REF"))
 
+        '''
         self.logger.debug("RPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
                           % (r_port_in_composition_instance_ref.getContextComponentRef().getDest(),
@@ -1994,6 +2123,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s"
                           % (r_port_in_composition_instance_ref.getTargetRPortRef().getDest(),
                              r_port_in_composition_instance_ref.getTargetRPortRef().getValue()))
+        '''
 
     def readAssemblySwConnectorProviderIRef(self, element: ET.Element, parent: AssemblySwConnector):
         child_element = self.find(element, "PROVIDER-IREF")
@@ -2016,7 +2146,7 @@ class ARXMLParser(AbstractARXMLParser):
         connector.setMappingRef(self.getChildElementOptionalRefType(element, "MAPPING-REF"))
 
     def readAssemblySwConnector(self, element: ET.Element, connector: AssemblySwConnector):
-        self.logger.debug("Read AssemblySwConnectors %s" % connector.getShortName())
+        # self.logger.debug("Read AssemblySwConnectors %s" % connector.getShortName())
         self.readSwConnector(element, connector)
         self.readAssemblySwConnectorProviderIRef(element, connector)
         self.readAssemblySwConnectorRequesterIRef(element, connector)
@@ -2053,7 +2183,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.raiseError("Unsupported child element of INNER-PORT-IREF")
 
     def readDelegationSwConnector(self, element, connector: DelegationSwConnector):
-        self.logger.debug("Read DelegationSwConnectors %s" % connector.getShortName())
+        # self.logger.debug("Read DelegationSwConnectors %s" % connector.getShortName())
         self.readSwConnector(element, connector)
         self.readDelegationSwConnectorInnerPortIRef(element, connector)
 
@@ -2061,7 +2191,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.raiseError("Invalid PortPrototype of DELEGATION-SW-CONNECTOR")
 
         connector.setOuterPortRef(self.getChildElementOptionalRefType(element, "OUTER-PORT-REF"))
-        self.logger.debug("OUTER-PORT-REF DEST: %s, %s" % (connector.getOuterPortRef().getDest(), connector.getOuterPortRef().getValue()))
+        # self.logger.debug("OUTER-PORT-REF DEST: %s, %s" % (connector.getOuterPortRef().getDest(), connector.getOuterPortRef().getValue()))
 
     def readSwComponentPrototype(self, element: ET.Element, prototype: SwComponentPrototype):
         self.logger.debug("Read SwComponentPrototypes <%s>" % prototype.getShortName())
@@ -2079,7 +2209,6 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readCompositionSwComponentTypeDataTypeMappingSet(self, element: ET.Element, parent: CompositionSwComponentType):
         child_element = self.find(element, "DATA-TYPE-MAPPING-REFS")
-        self.logger.debug("readDataTypeMappingSet")
         if child_element is not None:
             for ref in self.getChildElementRefTypeList(child_element, "DATA-TYPE-MAPPING-REF"):
                 parent.addDataTypeMapping(ref)
@@ -2213,7 +2342,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readParameterInterfaceParameters(element, interface)
 
     def readClientServerInterface(self, element: ET.Element, cs_interface: ClientServerInterface):
-        self.logger.debug("Read readClientServerInterface <%s>" % cs_interface.getShortName())
+        self.logger.debug("Read ClientServerInterface <%s>" % cs_interface.getShortName())
         self.readPortInterface(element, cs_interface)
         self.readClientServerInterfaceOperations(element, cs_interface)
         self.readPossibleErrors(element, cs_interface)
@@ -2248,7 +2377,7 @@ class ARXMLParser(AbstractARXMLParser):
     def readCompuConst(self, element: ET.Element, parent: CompuScale):
         child_element = self.find(element, "COMPU-CONST/VT")
         if (child_element is not None):
-            self.logger.debug("readCompuConst VT: %s" % child_element.text)
+            # self.logger.debug("Read CompuConst VT: %s" % child_element.text)
             contents = CompuScaleConstantContents()
             contents.compuConst = CompuConst()
             contents.compuConst.compuConstContentType = CompuConstTextContent()
@@ -2258,13 +2387,13 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readCompuNominatorDenominator(self, element: ET.Element, key: str, parent: CompuNominatorDenominator):
         for child_element in self.findall(element, "%s/V" % key):
-            self.logger.debug("readCompuNominatorDenominator - %s: %s" % (key, child_element.text))
+            # self.logger.debug("Read CompuNominatorDenominator - %s: %s" % (key, child_element.text))
             parent.add_v(child_element.text)
 
     def readCompuRationCoeffs(self, element: ET.Element, parent: CompuScale):
         child_element = self.find(element, "COMPU-RATIONAL-COEFFS")
         if (child_element is not None):
-            self.logger.debug("readCompuRationCoeffs")
+            # self.logger.debug("Read CompuRationCoeffs")
             contents = CompuScaleRationalFormula()
             contents.compuRationalCoeffs = CompuRationalCoeffs()
             contents.compuRationalCoeffs.compuDenominator = CompuNominatorDenominator()
@@ -2308,7 +2437,7 @@ class ARXMLParser(AbstractARXMLParser):
         return compu
 
     def readCompuMethod(self, element: ET.Element, compu_method: CompuMethod):
-        self.logger.debug("Read CompuMethods <%s>" % compu_method.getShortName())
+        self.logger.debug("Read CompuMethod <%s>" % compu_method.getShortName())
         self.readIdentifiable(element, compu_method)
         compu_method.setUnitRef(self.getChildElementOptionalRefType(element, "UNIT-REF")) \
                     .setCompuInternalToPhys(self.getCompu(element, "COMPU-INTERNAL-TO-PHYS")) \
@@ -2322,7 +2451,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.addRunnableMapping(mapping)
 
     def readSwcBswMapping(self, element: ET.Element, mapping: SwcBswMapping):
-        self.logger.debug("read SwcBswMappings %s" % mapping.getShortName())
+        self.logger.debug("Read SwcBswMapping <%s>" % mapping.getShortName())
         self.readIdentifiable(element, mapping)
         mapping.setBswBehaviorRef(self.getChildElementOptionalRefType(element, "BSW-BEHAVIOR-REF"))
         self.readSwcBswMappingSwcBswRunnableMappings(element, mapping)
@@ -2349,7 +2478,7 @@ class ARXMLParser(AbstractARXMLParser):
         return value_spec
     
     def getTextValueSpecification(self, element: ET.Element) -> TextValueSpecification:
-        self.logger.debug("getTextValueSpecification")
+        # self.logger.debug("Get TextValueSpecification")
         value_spec = TextValueSpecification()
         self.readValueSpecification(element, value_spec)
         value_spec.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
@@ -2357,7 +2486,7 @@ class ARXMLParser(AbstractARXMLParser):
         return value_spec
 
     def getArrayValueSpecification(self, element: ET.Element) -> ArrayValueSpecification:
-        self.logger.debug("getArrayValueSpecification")
+        # self.logger.debug("Get ArrayValueSpecification")
         value_spec = ArrayValueSpecification()
         self.readValueSpecification(element, value_spec)
         child_elements = element.findall("./xmlns:ELEMENTS/*", self.nsmap)
@@ -2366,7 +2495,7 @@ class ARXMLParser(AbstractARXMLParser):
         return value_spec
 
     def getConstantReference(self, element: ET.Element) -> ConstantReference:
-        self.logger.debug("getConstantReference")
+        # self.logger.debug("getConstantReference")
         value_spec = ConstantReference()
         self.readValueSpecification(element, value_spec)
         value_spec.setConstantRef(self.getChildElementOptionalRefType(element, "CONSTANT-REF"))
@@ -2400,7 +2529,7 @@ class ARXMLParser(AbstractARXMLParser):
         return value_spec
 
     def readConstantSpecification(self, element: ET.Element, spec: ConstantSpecification):
-        self.logger.debug("readConstantSpecification %s" % spec.getShortName())
+        self.logger.debug("Read ConstantSpecification <%s>" % spec.getShortName())
         self.readIdentifiable(element, spec)
         for child_element in self.findall(element, "VALUE-SPEC/*"):
             spec.setValueSpec(self.getValueSpecification(child_element, self.getTagName(child_element)))
@@ -2415,7 +2544,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.internalConstrs = constrs
 
     def readPhysConstrs(self, element: ET.Element, parent: DataConstrRule):
-        child_element = element.find("./xmlns:PHYS-CONSTRS", self.nsmap)
+        child_element = self.find(element, "PHYS-CONSTRS")
         if child_element is not None:
             constrs = PhysConstrs()
             self.readARObjectAttributes(child_element, constrs)
@@ -2425,8 +2554,8 @@ class ARXMLParser(AbstractARXMLParser):
             parent.physConstrs = constrs
                 
     def readDataConstrRule(self, element: ET.Element, parent: DataConstr):
-        for child_element in element.findall("./xmlns:DATA-CONSTR-RULES/xmlns:DATA-CONSTR-RULE", self.nsmap):
-            self.logger.debug("readDataConstrRule")
+        for child_element in self.findall(element, "DATA-CONSTR-RULES/DATA-CONSTR-RULE"):
+            # self.logger.debug("Read DataConstrRule")
             rule = DataConstrRule()
             self.readARObjectAttributes(child_element, rule)
             rule.constrLevel = self.getChildElementOptionalNumericalValue(child_element, "CONSTR-LEVEL")
@@ -2435,7 +2564,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.addDataConstrRule(rule)
                 
     def readDataConstr(self, element: ET.Element, constr: DataConstr):
-        self.logger.debug("Read DataConstr <%s>" % constr.getShortName())
+        # self.logger.debug("Read DataConstr <%s>" % constr.getShortName())
         self.readIdentifiable(element, constr)
         self.readDataConstrRule(element, constr)
 
@@ -4069,10 +4198,55 @@ class ARXMLParser(AbstractARXMLParser):
 
     def readDataTransformationSet(self, element: ET.Element, dtf_set: DataTransformationSet):
         self.logger.debug("Read DataTransformationSet <%s>" % dtf_set.getShortName())
-        self.readIdentifiable(element, dtf_set)
+        self.readARElement(element, dtf_set)
         self.readDataTransformationSetDataTransformations(element, dtf_set)
         self.readDataTransformationSetTransformationTechnologies(element, dtf_set)
 
+    def readCollectionElementRefs(self, element: ET.Element, collection: Collection):
+        for ref in self.getChildElementRefTypeList(element, "ELEMENT-REFS/ELEMENT-REF"):
+            collection.addElementRef(ref)
+
+    def readCollectionSourceElementRefs(self, element: ET.Element, collection: Collection):
+        for ref in self.getChildElementRefTypeList(element, "SOURCE-ELEMENT-REFS/SOURCE-ELEMENT-REF"):
+            collection.addSourceElementRef(ref)
+
+    def readCollection(self, element: ET.Element, collection: Collection):
+        self.logger.debug("Read Collection <%s>" % collection.getShortName())
+        self.readARElement(element, collection)
+        collection.setAutoCollect(self.getChildElementOptionalLiteral(element, "AUTO-COLLECT")) \
+                  .setElementRole(self.getChildElementOptionalLiteral(element, "ELEMENT-ROLE"))
+        self.readCollectionElementRefs(element, collection)
+        self.readCollectionSourceElementRefs(element, collection)
+
+    def readKeywordClassifications(self, element: ET.Element, keyword: Keyword):
+        for literal in self.getChildElementLiteralValueList(element, "CLASSIFICATIONS/CLASSIFICATION"):
+            keyword.addClassification(literal)
+
+    def readKeyword(self, element: ET.Element, keyword: Keyword):
+        # self.logger.debug("Read Keyword <%s>" % keyword.getShortName())
+        self.readIdentifiable(element, keyword)
+        keyword.setAbbrName(self.getChildElementOptionalLiteral(element, "ABBR-NAME"))
+        self.readKeywordClassifications(element, keyword)
+
+    def readKeywordSetKeywords(self, element: ET.Element, keyword_set: KeywordSet):
+        for child_element in self.findall(element, "KEYWORDS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "KEYWORD":
+                tech = keyword_set.createKeyword(self.getShortName(child_element))
+                self.readKeyword(child_element, tech)
+            else:
+                self.notImplemented("Unsupported Keyword <%s>" % tag_name)
+
+    def readKeywordSet(self, element: ET.Element, keyword_set: KeywordSet):
+        self.logger.debug("Read KeywordSet <%s>" % keyword_set.getShortName())
+        self.readARElement(element, keyword_set)
+        self.readKeywordSetKeywords(element, keyword_set)
+
+    def readPortPrototypeBlueprint(self, element: ET.Element, blueprint: PortPrototypeBlueprint):
+        self.logger.debug("Read PortPrototypeBlueprint <%s>" % blueprint.getShortName())
+        self.readARElement(element, blueprint)
+        blueprint.setInterfaceRef(self.getChildElementOptionalRefType(element, "INTERFACE-REF"))
+
     def readCommunicationController(self, element: ET.Element, controller: CommunicationController):
         controller.setWakeUpByControllerSupported(self.getChildElementOptionalBooleanValue(element, "WAKE-UP-BY-CONTROLLER-SUPPORTED"))
 
@@ -4525,20 +4699,10 @@ class ARXMLParser(AbstractARXMLParser):
         dimension.setLengthExp(self.getChildElementOptionalNumericalValue(element, "LENGTH-EXP")) \
                  .setLuminousIntensityExp(self.getChildElementOptionalNumericalValue(element, "LUMINOUS-INTENSITY-EXP")) \
                  .setMassExp(self.getChildElementOptionalNumericalValue(element, "MASS-EXP")) \
+                 .setMolarAmountExp(self.getChildElementOptionalNumericalValue(element, "MOLAR-AMOUNT-EXP")) \
                  .setTemperatureExp(self.getChildElementOptionalNumericalValue(element, "TEMPERATURE-EXP")) \
                  .setTimeExp(self.getChildElementOptionalNumericalValue(element, "TIME-EXP")) \
-                 .setCurrentExp(self.getChildElementOptionalNumericalValue(element, "CURRENT-EXP")) \
-
-    '''
-    def getIPduMappings(self, element: ET.Element) -> List[IPduMapping]:
-        mappings = []
-        for child_element in self.findall(element, tag_name):
-            mapping = IPduMapping()
-            mapping.sourceIPduRef = self.getChildElementOptionalRefType(child_element, "SOURCE-IPDU-REF")
-            mapping.targetIPduRef = self.getChildElementOptionalRefType(child_element, "TARGET-IPDU-REF")
-            mappings.append(mapping)
-        return mappings
-    '''
+                 .setCurrentExp(self.getChildElementOptionalNumericalValue(element, "CURRENT-EXP"))
 
     def readISignalGroupISignalRef(self, element: ET.Element, group: ISignalGroup):
         for ref_type in self.getChildElementRefTypeList(element, "I-SIGNAL-REFS/I-SIGNAL-REF"):
@@ -4657,7 +4821,7 @@ class ARXMLParser(AbstractARXMLParser):
         timing = None
         child_element = self.find(element, key)
         if child_element is not None:
-            self.logger.debug("Get TransmissionModeTiming of <%s>" % key)
+            # self.logger.debug("Get TransmissionModeTiming of <%s>" % key)
             timing = TransmissionModeTiming()
             timing.setCyclicTiming(self.getCyclicTiming(child_element, "CYCLIC-TIMING")) \
                   .setEventControlledTiming(self.getEventControlledTiming(child_element, "EVENT-CONTROLLED-TIMING"))
@@ -4766,7 +4930,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self.notImplemented("Unsupported Data Mapping %s" % tag_name)
 
     def readSwcToEcuMapping(self, element: ET.Element, mapping: SwcToEcuMapping):
-        self.logger.debug("SwcToEcuMapping %s" % mapping.getShortName())
+        # self.logger.debug("SwcToEcuMapping %s" % mapping.getShortName())
         self.readIdentifiable(element, mapping)
         for child_element in self.findall(element, "COMPONENT-IREFS/COMPONENT-IREF"):
             mapping.addComponentIRef(self.getComponentInSystemInstanceRef(child_element))
@@ -4811,7 +4975,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self.notImplemented("Unsupported SwImplMapping <%s>" % tag_name)
 
     def readSystemMapping(self, element: ET.Element, mapping: SystemMapping):
-        self.logger.debug("SystemMapping %s" % mapping.getShortName())
+        # self.logger.debug("Read SystemMapping <%s>" % mapping.getShortName())
         self.readIdentifiable(element, mapping)
         self.readSystemMappingDataMappings(element, mapping)
         self.readSystemMappingEcuResourceMappings(element, mapping)
@@ -4856,9 +5020,42 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("Read GenericEthernetFrame <%s>" % frame.getShortName())
         self.readFrame(element, frame)
 
+    def getLifeCyclePeriod(self, element: ET.Element, key: str) -> LifeCyclePeriod:
+        child_element = self.find(element, key)
+        period = None
+        if child_element is not None:
+            period = LifeCyclePeriod()
+            period.setArReleaseVersion(self.getChildElementOptionalRevisionLabelString(child_element, "AR-RELEASE-VERSION"))
+        return period
+    
+    def readLifeCycleInfoUseInsteadRefs(self, element: ET.Element, info: LifeCycleInfo):
+        for ref in self.getChildElementRefTypeList(element, "USE-INSTEAD-REFS/USE-INSTEAD-REF"):
+            info.addUseInsteadRef(ref)
+
+    def readLifeCycleInfo(self, element: ET.Element, info: LifeCycleInfo):
+        self.readARObjectAttributes(element, info)
+        info.setLcObjectRef(self.getChildElementOptionalRefType(element, "LC-OBJECT-REF")) \
+            .setLcStateRef(self.getChildElementOptionalRefType(element, "LC-STATE-REF")) \
+            .setPeriodBegin(self.getLifeCyclePeriod(element, "PERIOD-BEGIN")) \
+            .setRemark(self.getDocumentationBlock(element, "REMARK"))
+        self.readLifeCycleInfoUseInsteadRefs(element, info)
+
+    def readLifeCycleInfoSetLifeCycleInfos(self, element: ET.Element, info_set: LifeCycleInfoSet):
+        for child_element in self.findall(element, "LIFE-CYCLE-INFOS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "LIFE-CYCLE-INFO":
+                info = LifeCycleInfo()
+                self.readLifeCycleInfo(child_element, info)
+                info_set.addLifeCycleInfo(info)
+            else:
+                self.notImplemented("Unsupported Life Cycle Info <%s>" % tag_name)
+
     def readLifeCycleInfoSet(self, element: ET.Element, info_set: LifeCycleInfoSet):
         self.logger.debug("Read LifeCycleInfoSet <%s>" % info_set.getShortName())
         self.readIdentifiable(element, info_set)
+        info_set.setDefaultLcStateRef(self.getChildElementOptionalRefType(element, "DEFAULT-LC-STATE-REF"))
+        self.readLifeCycleInfoSetLifeCycleInfos(element, info_set)
+        info_set.setUsedLifeCycleStateDefinitionGroupRef(self.getChildElementOptionalRefType(element, "USED-LIFE-CYCLE-STATE-DEFINITION-GROUP-REF"))
 
     def readFlatInstanceDescriptor(self, element: ET.Element, desc: FlatInstanceDescriptor):
         self.logger.debug("Read LifeCycleInfoSet %s" % desc.getShortName())
@@ -4889,18 +5086,40 @@ class ARXMLParser(AbstractARXMLParser):
             mappings.append(mapping)
         return mappings
 
-    def getVariableAndParameterInterfaceMapping(self, element: ET.Element, mapping: VariableAndParameterInterfaceMapping):
-        self.logger.debug("get VariableAndParameterInterfaceMapping %s" % mapping.getShortName())
+    def readVariableAndParameterInterfaceMapping(self, element: ET.Element, mapping: VariableAndParameterInterfaceMapping):
+        # self.logger.debug("Read VariableAndParameterInterfaceMapping %s" % mapping.getShortName())
         self.readIdentifiable(element, mapping)
         for item in self.getDataPrototypeMappings(element, "DATA-MAPPINGS"):
             mapping.addDataMapping(item)
 
+    def readClientServerOperationMapping(self, element: ET.Element, mapping: ClientServerOperationMapping):
+        mapping.setFirstOperationRef(self.getChildElementOptionalRefType(element, "FIRST-OPERATION-REF")) \
+               .setSecondOperationRef(self.getChildElementOptionalRefType(element, "SECOND-OPERATION-REF"))
+
+    def readClientServerInterfaceMappingOperationMappings(self, element: ET.Element, mapping: ClientServerInterfaceMapping):
+        for child_element in self.findall(element, "OPERATION-MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CLIENT-SERVER-OPERATION-MAPPING":
+                operation_mapping = ClientServerOperationMapping()
+                self.readClientServerOperationMapping(child_element, operation_mapping)
+                mapping.addOperationMapping(operation_mapping)
+            else:
+                self.notImplemented("Unsupported Operation Mapping <%s>" % tag_name)
+
+    def readClientServerInterfaceMapping(self, element: ET.Element, mapping: ClientServerInterfaceMapping):
+        # self.logger.debug("Read ClientServerInterfaceMapping %s" % mapping.getShortName())
+        self.readIdentifiable(element, mapping)
+        self.readClientServerInterfaceMappingOperationMappings(element, mapping)
+
     def readPortInterfaceMappings(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
         for child_element in self.findall(element, "PORT-INTERFACE-MAPPINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "VARIABLE-AND-PARAMETER-INTERFACE-MAPPING":
                 mapping = mapping_set.createVariableAndParameterInterfaceMapping(self.getShortName(child_element))
-                self.getVariableAndParameterInterfaceMapping(child_element, mapping)
+                self.readVariableAndParameterInterfaceMapping(child_element, mapping)
+            elif tag_name == "CLIENT-SERVER-INTERFACE-MAPPING":
+                mapping = mapping_set.createClientServerInterfaceMapping(self.getShortName(child_element))
+                self.readClientServerInterfaceMapping(child_element, mapping)
             else:
                 self.notImplemented("Unsupported PortInterfaceMapping <%s>" % tag_name)
 
@@ -5137,8 +5356,17 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "DATA-TRANSFORMATION-SET":
                 transformation_set = parent.createDataTransformationSet(self.getShortName(child_element))
                 self.readDataTransformationSet(child_element, transformation_set)
+            elif tag_name == "COLLECTION":
+                collection = parent.createCollection(self.getShortName(child_element))
+                self.readCollection(child_element, collection)
+            elif tag_name == "KEYWORD-SET":
+                keyword_set = parent.createKeywordSet(self.getShortName(child_element))
+                self.readKeywordSet(child_element, keyword_set)
+            elif tag_name == "PORT-PROTOTYPE-BLUEPRINT":
+                keyword_set = parent.createPortPrototypeBlueprint(self.getShortName(child_element))
+                self.readPortPrototypeBlueprint(child_element, keyword_set)
             else:
-                self.notImplemented("Unsupported element type of ARPackage <%s>" % tag_name)
+                self.notImplemented("Unsupported Element type of ARPackage <%s>" % tag_name)
 
     def readReferenceBases(self, element: ET.Element, parent: ARPackage):
         for child_element in self.findall(element, "REFERENCE-BASES/REFERENCE-BASE"):
@@ -5151,7 +5379,7 @@ class ARXMLParser(AbstractARXMLParser):
             parent.addReferenceBase(base)
 
     def readARPackage(self, element: ET.Element, ar_package: ARPackage):
-        self.logger.debug("Read ARPackages %s" % ar_package.getFullName())
+        self.logger.debug("Read ARPackages <%s>" % ar_package.getFullName())
 
         self.readIdentifiable(element, ar_package)
         self.readARPackages(element, ar_package)