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

armodel/parser/arxml_parser.py

@@ -1,255 +1,164 @@
-from ..models.unit import Unit
+from typing import List
+import xml.etree.ElementTree as ET
+
+from armodel.models.fibex.fibex_4_multiplatform import FrameMapping, IPduMapping, ISignalMapping
+
+from ..models.fibex.fibex_core import Frame
+from ..models.internal_behavior import IncludedDataTypeSet
+from ..models.timing import ExecutionOrderConstraint, TimingExtension
+from ..models.bsw_module_template import BswModeSenderPolicy
+from ..models.port_interface import ModeSwitchInterface, PortInterface
+from ..models.common_structure import IncludedModeDeclarationGroupSet, MemorySection, ModeDeclarationGroup, ModeDeclarationGroupPrototype, ModeRequestTypeMap
+from ..models.implementation import BswImplementation, EngineeringObject
+from ..models.general_structure import MultilanguageReferrable
+from ..models.multilanguage_data import LOverviewParagraph, MultiLanguageOverviewParagraph, LLongName, MultilanguageLongName
+from ..models.data_def_properties import ValueList
+from ..models.record_layout import SwRecordLayoutGroup, SwRecordLayoutGroupContent, SwRecordLayoutV
+from ..models.datatype import ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, AutosarDataType, BaseTypeDirectDefinition
+from ..models.calibration import SwAxisGrouped, SwAxisIndividual, SwCalprmAxis, SwCalprmAxisSet
+from ..models.communication import CompositeNetworkRepresentation
+from ..models.end_to_end_protection import EndToEndDescription, EndToEndProtection, EndToEndProtectionSet, EndToEndProtectionVariablePrototype
+from ..models.service_mapping import RoleBasedPortAssignment
+from ..models.ar_package import AUTOSAR, ARPackage
+from ..models.ar_object import ARLiteral
+from ..models.service_needs import RoleBasedDataAssignment
+from ..models.ar_ref import ApplicationCompositeElementInPortInterfaceInstanceRef, InnerPortGroupInCompositionInstanceRef, RModeGroupInAtomicSWCInstanceRef, VariableDataPrototypeInSystemInstanceRef, VariableInAtomicSWCTypeInstanceRef, AutosarParameterRef
+from ..models.sw_component import AtomicSwComponentType, CompositionSwComponentType, ModeAccessPoint, PortAPIOption, PortDefinedArgumentValue, PortGroup, ServiceDependency, SwComponentType, SwcServiceDependency
+from ..models.data_prototype import ApplicationCompositeElementDataPrototype, AutosarDataPrototype, DataPrototype, ParameterDataPrototype
+from ..models.port_prototype import ModeSwitchReceiverComSpec, QueuedReceiverComSpec
+from ..models.annotation import Annotation, GeneralAnnotation
 from ..models.global_constraints import InternalConstrs, DataConstr, DataConstrRule, PhysConstrs
 
-from ..models import AUTOSAR, ARPackage, ARObject, EcuAbstractionSwComponentType, AtomicSwComponentType, SwComponentType, CompositionSwComponentType
-from ..models import SwcInternalBehavior, RunnableEntity, RTEEvent, VariableAccess, ServerCallPoint, OperationInvokedEvent, DataReceivedEvent, RVariableInAtomicSwcInstanceRef
+from ..models import SwcInternalBehavior, RunnableEntity, RTEEvent, ServerCallPoint, OperationInvokedEvent, DataReceivedEvent, RVariableInAtomicSwcInstanceRef
 from ..models import SwcModeSwitchEvent, RModeInAtomicSwcInstanceRef
-from ..models import RefType, AutosarVariableRef, ArVariableInImplementationDataInstanceRef, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef
+from ..models import AutosarVariableRef, POperationInAtomicSwcInstanceRef, ROperationInAtomicSwcInstanceRef
 from ..models import ImplementationDataType, SwDataDefProps, SwPointerTargetProps, DataTypeMappingSet, DataTypeMap, ImplementationDataTypeElement
-from ..models import DataPrototype, RPortPrototype, PPortPrototype
-from ..models import ReceiverComSpec, ClientComSpec, NonqueuedReceiverComSpec, QueuedReceiverComSpec
-from ..models import SenderComSpec, NonqueuedSenderComSpec
+from ..models import RPortPrototype, PPortPrototype
+from ..models import ReceiverComSpec, ClientComSpec, NonqueuedReceiverComSpec
+from ..models import SenderComSpec, NonqueuedSenderComSpec, ServerComSpec
 from ..models import SenderReceiverInterface, ClientServerInterface, ClientServerOperation, ArgumentDataPrototype
-from ..models import AutosarDataType, ARElement, Identifiable, AdminData, Sdg, Sd, MultilanguageReferrable, Referrable, LLongName, MultilanguageLongName
+from ..models import Identifiable, AdminData, Sdg, Sd
 from ..models import AssemblySwConnector, PPortInCompositionInstanceRef, RPortInCompositionInstanceRef
 from ..models import DelegationSwConnector
-from ..models import CompuMethod, CompuScale, Limit, CompuScales, Compu, CompuConst, CompuConstTextContent, CompuScaleConstantContents, CompuScaleRationalFormula, CompuRationalCoeffs, CompuNominatorDenominator
+from ..models import CompuMethod, CompuScale, CompuScales, Compu, CompuConst, CompuConstTextContent, CompuScaleConstantContents, CompuScaleRationalFormula, CompuRationalCoeffs, CompuNominatorDenominator
 from ..models import InternalBehavior, ExecutableEntity
 from ..models import Implementation, Code, AutosarEngineeringObject, ResourceConsumption
 from ..models import TransmissionAcknowledgementRequest
-from ..models import BswImplementation, BswModuleDescription, BswInternalBehavior, BswCalledEntity, BswModuleEntity, BswScheduleEvent, SwcBswMapping, SwcBswRunnableMapping
+from ..models import BswModuleDescription, BswInternalBehavior, BswModuleEntity, BswScheduleEvent, SwcBswMapping, SwcBswRunnableMapping
 from ..models import ValueSpecification, ApplicationValueSpecification, TextValueSpecification, NumericalValueSpecification, ArrayValueSpecification, ConstantReference
-from ..models import ConstantSpecification, RecordValueSpecification
+from ..models import RecordValueSpecification
 from ..models import ApplicationRecordDataType
 from ..models import SwValueCont, SwValues
-from ..models import ARBoolean, ARLiteral
-from ..models import BaseType
-
-from typing import List
-from colorama import Fore
-import xml.etree.ElementTree as ET
-import re
-import logging
-
-class ARXMLParser:
-    def __init__(self, options = None):
-        self.nsmap = {"xmlns": "http://autosar.org/schema/r4.0"}
-        self.options = {}
-        self.options['warning'] = False
-        self.logger = logging.getLogger()
-        
-        self._processOptions(options=options)
-
-    def _processOptions(self, options):
-        if options:
-            if 'warning' in options:
-                self.options['warning'] = options['warning']
 
-    def _raiseError(self, error_msg):
-        if (self.options['warning'] == True):
-            self.logger.error(Fore.RED + error_msg + Fore.WHITE)
-        else:
-            raise ValueError(error_msg)
-
-    def getPureTagName(self, tag):
-        return re.sub(r'\{[\w:\/.]+\}(\w+)', r'\1', tag)
-
-    def readChildElement(self, short_name: str, element: ET.Element, key: str) -> str:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
-        if (child_element != None):
-            return child_element.text
-        self._raiseError("The attribute %s of <%s> has not been defined" % (key, short_name))
+from .abstract_arxml_parser import AbstractARXMLParser
 
-    def readChildOptionalElement(self, element: ET.Element, key: str) -> str:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
-        if (child_element != None):
-            return child_element.text
-        return None
-    
-    def readChildElementLiteral(self, short_name: str, element: ET.Element, key: str) -> ARLiteral:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
-        if (child_element != None):
-            literal = ARLiteral()
-            self.readElementAttributes(child_element, literal)
-            literal.value = child_element.text
-            return literal
-        self._raiseError("The attribute %s of <%s> has not been defined" % (key, short_name))
-
-    def readChildOptionalElementLiteral(self, element: ET.Element, key: str) -> ARLiteral:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
-        if (child_element != None):
-            self.logger.debug("readChildOptionalElementLiteral : %s" % child_element.text)
-            literal = ARLiteral()
-            self.readElementAttributes(child_element, literal)
-            literal.value = child_element.text
-            return literal
-        return None
-
-    def _convertStringToBooleanValue(self, value: str) -> bool:
-        if (value == "true"):
-            return True
-        return False
-    
-    def readChildElementFloatValue(self, short_name: str, element: ET.Element, key: str) -> float:
-        value = self.readChildElement(short_name, element, key)
-        if (value == None):
-            return None
-        return float(value)
-
-    def readChildElementBooleanValue(self, short_name: str, element: ET.Element, key: str) -> ARBoolean:
-        literal = self.readChildElementLiteral(short_name, element, key)
-        bool_value = ARBoolean()
-        bool_value.timestamp = literal.timestamp
-        bool_value.value = self._convertStringToBooleanValue(literal.value)
-        return bool_value
-
-    def readChildOptionalElementBooleanValue(self, element: ET.Element, key: str) -> ARBoolean:
-        literal = self.readChildOptionalElementLiteral(element, key)
-        if (literal == None):
-            return None
-        bool_value = ARBoolean()
-        bool_value.timestamp = literal.timestamp
-        bool_value.value = self._convertStringToBooleanValue(literal.value)
-        return bool_value
-
-    def _convertStringToNumberValue(self, value) -> int:
-        m = re.match(r"0x([0-9a-f]+)", value, re.I)
-        if (m):
-            return int(m.group(1), 16)
-        return int(value)
-
-    def readChildElementNumberValue(self, short_name: str, element: ET.Element, key: str) -> int:
-        value = self.readChildElement(short_name, element, key)
-        return self._convertStringToNumberValue(value)
-
-    def readChildOptionalElementNumberValue(self, element: ET.Element, key: str) -> int:
-        value = self.readChildOptionalElement(element, key)
-        if (value == None):
-            return None
-        return self._convertStringToNumberValue(value)
-    
-    def readChildLimitElement(self, element: ET.Element, key: str) -> Limit:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
-        if (child_element != None):
-            limit = Limit()
-            if ('INTERVAL-TYPE' in child_element.attrib):
-                limit.interval_type = child_element.attrib['INTERVAL-TYPE']
-            else:
-                limit.interval_type = "CLOSED"
-            limit.value = child_element.text
-            return limit
-        return None
-    
-    def readShortName(self, element: ET.Element) -> str:
-        return self.readChildElement("", element, "SHORT-NAME")
+class ARXMLParser(AbstractARXMLParser):
+    def __init__(self, options=None) -> None:
+        super().__init__(options)
+        
+    def getShortName(self, element: ET.Element) -> str:
+        child_element = self.find(element, "SHORT-NAME")
+        if child_element is None:
+            raise ValueError("Short Name is required")
+        return child_element.text
     
     def readSd(self, element: ET.Element, sdg: Sdg):
-        for child_element in element.findall("./xmlns:SD", self.nsmap):
+        for child_element in self.findall(element, "./SD"):
             sd = Sd()
-            sd.gid = child_element.attrib['GID']
+            if 'GID' in child_element.attrib:
+                sd.gid = child_element.attrib['GID']
             sd.value = child_element.text
-
             sdg.addSd(sd)
+
+    def getSdg(self, element: ET.Element) -> Sdg:
+        sdg = Sdg()
+        if 'GID' in element.attrib:
+            sdg.gid = element.attrib["GID"]
+        self.readSd(element, sdg)
+        child_element = self.find(element, "./SDG")
+        if child_element is not None:
+            sdg.sdg_contents_type = self.getSdg(child_element)
+        return sdg
     
-    def readSdg(self, element: ET.Element, admin_data: AdminData):
-        for child_element in element.findall("./xmlns:SDGS/xmlns:SDG", self.nsmap):
-            sdg = Sdg()
-            sdg.gid = child_element.attrib["GID"]
-            self.readSd(child_element, sdg)
-            admin_data.addSdg(sdg)
+    def readSdgs(self, element: ET.Element, admin_data: AdminData):
+        for child_element in self.findall(element, "./SDGS/SDG"):
+            admin_data.addSdg(self.getSdg(child_element))
     
     def readAdminData(self, element: ET.Element, identifiable: Identifiable):
-        child_element = element.find("./xmlns:ADMIN-DATA", self.nsmap)
+        child_element = self.find(element, "./ADMIN-DATA")
         if child_element is not None:
             self.logger.debug("readAdminData")
             admin_data = AdminData()
-            self.readSdg(child_element, admin_data)
+            self.readSdgs(child_element, admin_data)
             identifiable.admin_data = admin_data
+
+    def readMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
+        self.readElementAttributes(element, referrable)
+        referrable.long_name = self.getMultilanguageLongName(element, "LONG-NAME")
     
     def readIdentifiable(self, element: ET.Element, identifiable: Identifiable):
-        self.readElementAttributes(element, identifiable)
         self.readMultilanguageReferrable(element, identifiable)
-        identifiable.category = self.readChildOptionalElement(element, "CATEGORY")
+        identifiable.category = self.getChildElementOptionalLiteral(element, "CATEGORY")
+        identifiable.desc = self.getMultiLanguageOverviewParagraph(element, "DESC")
         self.readAdminData(element, identifiable)
-
-    def _readChildRefElementDestAndValue(self, element) -> RefType:
-        ref = RefType()
-        ref.dest = element.attrib['DEST']
-        ref.value = element.text
-        return ref
-
-    def readChildRefElement(self, short_name: str, element: ET.Element, key: str) -> RefType:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
-        if (child_element != None):
-            return self._readChildRefElementDestAndValue(child_element)
-        self._raiseError("The attribute %s of <%s> has not been defined" % (key, short_name))
-
-    def readChildOptionalRefElement(self, element:ET.Element, key: str) -> RefType:
-        child_element = element.find("./xmlns:%s" % key, self.nsmap)
-        if (child_element != None):
-            return self._readChildRefElementDestAndValue(child_element)
-        return None
-
-    def readChildRefElementList(self, element: ET.Element, key: str) -> List[RefType]:
-        child_elements = element.findall("./xmlns:%s" % key, self.nsmap)
-        results = []
-        for child_element in child_elements:
-            ref = RefType()
-            ref.dest = child_element.attrib['DEST']
-            ref.value = child_element.text
-            results.append(ref)
-        return results
     
-    def readElementOptionalAttrib(self, element: ET.Element, key: str) -> str:
-        if key in element.attrib:
-            return element.attrib[key]
-        return None
-    
-    def readMultilanguageLongName(self, element: ET.Element, long_name: MultilanguageLongName):
-        for child_element in element.findall("./xmlns:L-4", self.nsmap):
+    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)
             l4.value = child_element.text
             if 'L' in child_element.attrib:
                 l4.l = child_element.attrib['L']
-            long_name.add_l4(l4)
+            long_name.addL4(l4)
     
-    def readMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
-        child_element = element.find("./xmlns:LONG-NAME", self.nsmap)
+    def getMultilanguageLongName(self, element: ET.Element, key: str) -> MultilanguageLongName:
+        long_name = None
+        child_element = self.find(element, "./%s" % key)
         if child_element is not None:
-            referrable.long_name = MultilanguageLongName()
-            self.readElementAttributes(child_element, referrable.long_name)
-            self.readMultilanguageLongName(child_element, referrable.long_name)
-
-    def readElementAttributes(self, element: ET.Element, ar_object: ARObject):
-        ar_object.timestamp = self.readElementOptionalAttrib(element, "T")             # read the timestamp
-        ar_object.uuid      = self.readElementOptionalAttrib(element, "UUID")          # read the uuid
-
-        if ar_object.timestamp is not None:
-            self.logger.debug("Timestamp: %s" % ar_object.timestamp)
-        if ar_object.uuid is not None:
-            self.logger.debug("UUID: %s" % ar_object.uuid)
+            long_name = MultilanguageLongName()
+            self.readElementAttributes(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)
+            l2.value = child_element.text
+            if 'L' in child_element.attrib:
+                l2.l = child_element.attrib['L']
+            paragraph.addL2(l2)
+    
+    def getMultiLanguageOverviewParagraph(self, element: ET.Element, key: str) -> MultiLanguageOverviewParagraph:
+        paragraph = None
+        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        if child_element is not None:
+            paragraph = MultiLanguageOverviewParagraph()
+            self.readElementAttributes(child_element, paragraph)
+            self.readLOverviewParagraph(child_element, paragraph)
+        return paragraph
 
     def readAutosarVariableInImplDatatype(self, element: ET.Element, accessed_variable_ref: AutosarVariableRef):
         child_element = element.find("./xmlns:ACCESSED-VARIABLE/xmlns:AUTOSAR-VARIABLE-IREF", self.nsmap)
-        if (child_element != None):
-            autosar_variable_in_impl_datatype = ArVariableInImplementationDataInstanceRef()
-            autosar_variable_in_impl_datatype.port_prototype_ref = self.readChildOptionalRefElement(child_element, "PORT-PROTOTYPE-REF")
-            if autosar_variable_in_impl_datatype.port_prototype_ref is None:
+        if (child_element is not None):
+            autosar_variable_iref = VariableInAtomicSWCTypeInstanceRef()
+            self.readElementAttributes(child_element, autosar_variable_iref)
+            autosar_variable_iref.port_prototype_ref = self.getChildElementOptionalRefType(child_element, "PORT-PROTOTYPE-REF")
+            if autosar_variable_iref.port_prototype_ref is None:
                 self._raiseError("PORT-PROTOTYPE-REF of <%s> is empty." % accessed_variable_ref.parent.short_name)
-            autosar_variable_in_impl_datatype.target_data_prototype_ref = self.readChildOptionalRefElement(child_element, "TARGET-DATA-PROTOTYPE-REF")
-            if autosar_variable_in_impl_datatype.target_data_prototype_ref is None:
+            autosar_variable_iref.target_data_prototype_ref = self.getChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF")
+            if autosar_variable_iref.target_data_prototype_ref is None:
                 self._raiseError("TARGET-DATA-PROTOTYPE-REF of <%s> is empty." % accessed_variable_ref.parent.short_name)
-            accessed_variable_ref.autosar_variable_in_impl_datatype = autosar_variable_in_impl_datatype
+            accessed_variable_ref.autosar_variable_iref = autosar_variable_iref
 
     def readLocalVariableRef(self, element, accessed_variable_ref: AutosarVariableRef):
         child_element = element.find("./xmlns:ACCESSED-VARIABLE", self.nsmap)
-        if (child_element != None):
-            accessed_variable_ref.local_variable_ref = self.readChildOptionalRefElement(child_element, "LOCAL-VARIABLE-REF")
+        if (child_element is not None):
+            accessed_variable_ref.local_variable_ref = self.getChildElementOptionalRefType(child_element, "LOCAL-VARIABLE-REF")
 
     def _readVariableAccesses(self, element: ET.Element, parent: RunnableEntity, key: str):
         for child_element in element.findall("./xmlns:%s/xmlns:VARIABLE-ACCESS" % key, self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
 
             self.logger.debug("readVariableAccesses %s" % short_name)
 
@@ -262,6 +171,9 @@ class ARXMLParser:
             elif (key == "DATA-READ-ACCESSS"):
                 variable_access = parent.createDataReadAccess(short_name)
                 self.readAutosarVariableInImplDatatype(child_element, variable_access.accessed_variable_ref)
+            elif (key == "DATA-WRITE-ACCESSS"):
+                variable_access = parent.createDataWriteAccess(short_name)
+                self.readAutosarVariableInImplDatatype(child_element, variable_access.accessed_variable_ref)
             elif (key == "DATA-SEND-POINTS"):
                 variable_access = parent.createDataSendPoint(short_name)
                 self.readAutosarVariableInImplDatatype(child_element, variable_access.accessed_variable_ref)
@@ -274,47 +186,60 @@ class ARXMLParser:
             else:
                 self._raiseError("Invalid key type <%s>" % key)
 
-            # self.readIdentifiable(child_element, variable_access)
+            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):
-            ref = self.readChildOptionalRefElement(child_element, "BSW-MODULE-ENTRY-REF") 
-            if (ref != None):
-                parent.implemented_entry_refs.append(ref)
+            ref = self.getChildElementOptionalRefType(child_element, "BSW-MODULE-ENTRY-REF") 
+            if (ref is not None):
+                parent.addImplementedEntry(ref)
             self.logger.debug("ImplementedEntry <%s> of BswModuleDescription <%s> has been added", ref.value, parent.short_name)
 
+    def readModeDeclarationGroupPrototype(self, element: ET.Element, prototype: ModeDeclarationGroupPrototype):
+        self.readIdentifiable(element, prototype)
+        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):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readProvidedModeGroup %s" % short_name)
 
             mode_group = parent.createProvidedModeGroup(short_name)
-            mode_group.type_tref = self.readChildRefElement(parent.short_name, child_element, "TYPE-TREF")
+            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):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readRequiredModeGroup %s" % short_name)
             mode_group = parent.createProvidedModeGroup(short_name)
-            mode_group.type_tref = self.readChildRefElement(parent.short_name, child_element, "TYPE-TREF")
+            mode_group.type_tref = self.getChildElementRefType(parent.short_name, child_element, "TYPE-TREF")
 
     def readCanEnterExclusiveAreaRefs(self, element: ET.Element, entity: ExecutableEntity):
         child_element = element.find("./xmlns:CAN-ENTER-EXCLUSIVE-AREA-REFS", self.nsmap)
-        if child_element != None:
-            for ref in self.readChildRefElementList(child_element, "CAN-ENTER-EXCLUSIVE-AREA-REF"):
+        if child_element is not None:
+            for ref in self.getChildElementRefTypeList(child_element, "./CAN-ENTER-EXCLUSIVE-AREA-REF"):
                 entity.addCanEnterExclusiveAreaRef(ref)
 
     def readExecutableEntity(self, element: ET.Element, entity: ExecutableEntity):
+        self.logger.debug("readExecutableEntity %s" % entity.short_name)
+        self.readIdentifiable(element, entity)
         self.readCanEnterExclusiveAreaRefs(element, entity)
+        entity.minimum_start_interval = self.getChildElementOptionalFloatValue(element, "MINIMUM-START-INTERVAL")
 
-    def readBswModuleEntity(self, element, entity: BswModuleEntity):
+    def readBswModuleEntityManagedModeGroup(self, element: ET.Element, entity: BswModuleEntity):
+        for child_element in self.findall(element, "./MANAGED-MODE-GROUPS/MODE-DECLARATION-GROUP-PROTOTYPE-REF-CONDITIONAL"):
+            ref_type = self.getChildElementOptionalRefType(child_element, "MODE-DECLARATION-GROUP-PROTOTYPE-REF")
+            if ref_type is not None:
+                entity.addManagedModeGroupRef(ref_type)
+
+    def readBswModuleEntity(self, element: ET.Element, entity: BswModuleEntity):
         self.readExecutableEntity(element, entity)
-        
-        entity.implemented_entry_ref = self.readChildRefElement(entity.short_name, element, "IMPLEMENTED-ENTRY-REF")
+        entity.implemented_entry_ref = self.getChildElementRefType(entity.short_name, element, "IMPLEMENTED-ENTRY-REF")
+        self.readBswModuleEntityManagedModeGroup(element, entity)
 
     def readBswCalledEntity(self, element: ET.Element, parent: BswInternalBehavior):
         for child_element in element.findall("./xmlns:ENTITYS/xmlns:BSW-CALLED-ENTITY", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readBswCalledEntity %s" % short_name)
             entity = parent.createBswCalledEntity(short_name)
 
@@ -322,187 +247,329 @@ class ARXMLParser:
 
     def readBswSchedulableEntity(self, element: ET.Element, parent: BswInternalBehavior):
         for child_element in element.findall("./xmlns:ENTITYS/xmlns:BSW-SCHEDULABLE-ENTITY", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readBswSchedulableEntity %s" % short_name)
             entity = parent.createBswSchedulableEntity(short_name)
-
             self.readBswModuleEntity(child_element, entity)
 
     def readBswEvent(self, element: ET.Element, event: BswScheduleEvent):
-        event.starts_on_event_ref = self.readChildRefElement(event.short_name, element, "STARTS-ON-EVENT-REF")
+        event.startsOnEventRef = self.getChildElementRefType(event.short_name, element, "STARTS-ON-EVENT-REF")
 
     def readBswScheduleEvent(self, element, event: BswScheduleEvent):
         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):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readBswModeSwitchEvent %s" % short_name)
             event = parent.createBswModeSwitchEvent(short_name)
-
+            # Read the Inherit BswScheduleEvent
             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):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readBswTimingEvent %s" % short_name)
             event = parent.createBswTimingEvent(short_name)
-            event.period = self.readChildElementFloatValue(short_name, child_element, "PERIOD")
-
+            event.period = self.getChildElementOptionalFloatValue(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):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readBswDataReceivedEvent %s" % short_name)
             event = parent.createBswDataReceivedEvent(short_name)
-            event.data_ref = self.readChildRefElement(parent.short_name, child_element, "DATA-REF")
-
+            event.data_ref = self.getChildElementRefType(parent.short_name, 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 element.findall("./xmlns:EVENTS/xmlns:BSW-INTERNAL-TRIGGER-OCCURRED-EVENT", self.nsmap):
-            short_name = self.readShortName(child_element)
+        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.readChildRefElement(parent.short_name, child_element, "EVENT-SOURCE-REF")
-
+            event.event_source_ref = self.getChildElementRefType(parent.short_name, child_element, "EVENT-SOURCE-REF")
+            # Read the Inherit BswScheduleEvent
             self.readBswScheduleEvent(child_element, event)
 
+    def getBswModeSenderPolicy(self, element: ET.Element) -> BswModeSenderPolicy:
+        policy = BswModeSenderPolicy()
+        policy.setProvidedModeGroupRef(self.getChildElementOptionalRefType(element, "PROVIDED-MODE-GROUP-REF"))
+        policy.setQueueLength(self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH"))
+        return policy
+
+    def readBswInternalBehaviorModeSenderPolicy(self, element: ET.Element, parent: BswInternalBehavior):
+        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))
+            else:
+                self._raiseError("Unsupported ModeSenderPolicy type <%s>." % tag_name)
+
     def readDataTypeMappingRefs(self, element: ET.Element, behavior: InternalBehavior):
         child_element = element.find("./xmlns:DATA-TYPE-MAPPING-REFS", self.nsmap)
-        if child_element != None:
-            for ref in self.readChildRefElementList(child_element, "DATA-TYPE-MAPPING-REF"):
+        if child_element is not None:
+            for ref in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-MAPPING-REF"):
                 behavior.addDataTypeMappingRef(ref)
 
+    def readInternalBehaviorConstantMemories(self, element: ET.Element, behavior: InternalBehavior):
+        for child_element in element.findall("./xmlns:CONSTANT-MEMORYS/xmlns:PARAMETER-DATA-PROTOTYPE", self.nsmap):
+            short_name = self.getShortName(child_element)
+            prototype = behavior.createConstantMemory(short_name)
+            self.readParameterDataPrototype(child_element, prototype)
+
     def readInternalBehavior(self, element: ET.Element, behavior: InternalBehavior):
+        self.readIdentifiable(element, behavior)
+        self.readInternalBehaviorConstantMemories(element, behavior)
         for child_element in element.findall("./xmlns:EXCLUSIVE-AREAS/xmlns:EXCLUSIVE-AREA", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             behavior.createExclusiveArea(short_name)
-
         self.readDataTypeMappingRefs(element, behavior)
 
-    def readSwInternalBehavior(self, element: ET.Element, parent: AtomicSwComponentType):
-        for child_element in element.findall("./xmlns:INTERNAL-BEHAVIORS/xmlns:SWC-INTERNAL-BEHAVIOR", self.nsmap):
-            short_name = self.readShortName(child_element)
+    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")
+        return assignment
+    
+    def getRoleBasedPortAssignment(self, element: ET.Element) -> RoleBasedPortAssignment:
+        assignment = RoleBasedPortAssignment()
+        assignment.port_prototype_ref = self.getChildElementOptionalRefType(element, "PORT-PROTOTYPE-REF")
+        assignment.role = self.getChildElementOptionalLiteral(element, "ROLE")
+        return assignment
+
+    def readServiceDependency(self, element: ET.Element, dependency: ServiceDependency):
+        self.readIdentifiable(element, dependency)
+
+    def readSwcServiceDependencyAssignedData(self, element: ET.Element, dependency: SwcServiceDependency):
+        for child_element in element.findall("./xmlns:ASSIGNED-DATAS/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if (tag_name == "ROLE-BASED-DATA-ASSIGNMENT"):
+                dependency.AddAssignedData(self.getRoleBasedDataAssignment(child_element))
+            else:
+                self._raiseError("Unsupported assigned data <%s>" % tag_name)
+
+    def readSwcServiceDependencyAssignedPorts(self, element: ET.Element, dependency: SwcServiceDependency):
+        for child_element in element.findall("./xmlns:ASSIGNED-PORTS/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if (tag_name == "ROLE-BASED-PORT-ASSIGNMENT"):
+                dependency.AddAssignedPort(self.getRoleBasedPortAssignment(child_element))
+            else:
+                self._raiseError("Unsupported assigned ports <%s>" % tag_name)
+
+    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")                          
+
+    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)    
+            else:
+                self._raiseError("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("readSwcServiceDependency %s" % short_name)
+        self.readServiceDependency(element, dependency)
+        self.readSwcServiceDependencyAssignedData(element, dependency)
+        self.readSwcServiceDependencyAssignedPorts(element, dependency)
+        self.readSwcServiceDependencyServiceNeeds(element, dependency)
+
+    def readSwcInternalBehaviorServiceDependencies(self, element: ET.Element, parent: SwcInternalBehavior):
+        for child_element in element.findall("./xmlns:SERVICE-DEPENDENCYS/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if (tag_name == "SWC-SERVICE-DEPENDENCY"):
+                self.readSwcServiceDependency(child_element, parent)
+            else:
+                self._raiseError("Unsupported Service Dependencies <%s>" % tag_name)
+
+    def getIncludedDataTypeSets(self, element: ET.Element) -> List[IncludedDataTypeSet]:
+        include_data_type_sets = []
+        for child_element in self.findall(element, "./INCLUDED-DATA-TYPE-SETS/INCLUDED-DATA-TYPE-SET"):
+            include_data_type_set = IncludedDataTypeSet()
+            self.readElementAttributes(child_element, include_data_type_set)
+            for ref_type in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-REFS/DATA-TYPE-REF"):
+                include_data_type_set.addDataTypeRef(ref_type)
+            include_data_type_sets.append(include_data_type_set)
+        return include_data_type_sets
+
+    def readSwcInternalBehavior(self, element: ET.Element, parent: AtomicSwComponentType):
+        for child_element in self.findall(element, "./INTERNAL-BEHAVIORS/SWC-INTERNAL-BEHAVIOR"):
+            short_name = self.getShortName(child_element)
             behavior = parent.createSwcInternalBehavior(short_name)
-            self.logger.debug("readSwInternalBehavior %s" % behavior.full_name)
+            self.logger.debug("readSwcInternalBehavior %s" % behavior.full_name)
 
             # read the internal behavior
             self.readInternalBehavior(child_element, behavior)
-
-            self.readRunnableEntities(child_element, behavior)
-            self.readOperationInvokedEvents(child_element, behavior)
-            self.readTimingEvents(child_element, behavior)
-            self.readInternalTriggerOccurredEvent(child_element, behavior)
+            
+            # read the extra SwcInternalBehavior
+            self.readSwcInternalBehaviorRunnables(child_element, behavior)
+            self.readSwcInternalBehaviorEvents(child_element, behavior)
+            self.readSwcInternalBehaviorServiceDependencies(child_element, behavior)
             self.readExplicitInterRunnableVariables(child_element, behavior)
+            for data_type_set  in self.getIncludedDataTypeSets(child_element):
+                behavior.addIncludedDataTypeSet(data_type_set)
+            behavior.handle_termination_and_restart = self.getChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART")
+            self.readPerInstanceMemories(child_element, behavior)
+            self.readPerInstanceParameters(child_element, behavior)
+            self.readPortAPIOptions(child_element, behavior)
+            behavior.supports_multiple_instantiation = self.getChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION")
+
+    def getIncludedModeDeclarationGroupSets(self, element: ET.Element) -> List[IncludedModeDeclarationGroupSet]:
+        group_sets = []
+        for child_element in self.findall(element, "INCLUDED-MODE-DECLARATION-GROUP-SETS/INCLUDED-MODE-DECLARATION-GROUP-SET"):
+            group_set = IncludedModeDeclarationGroupSet()
+            for ref_type in self.getChildElementRefTypeList(child_element, "./MODE-DECLARATION-GROUP-REFS/MODE-DECLARATION-GROUP-REF"):
+                group_set.addModeDeclarationGroupRef(ref_type)
+            group_sets.append(group_set)
+        return group_sets
 
     def readBswInternalBehavior(self, element: ET.Element, parent: BswModuleDescription):
         for child_element in element.findall("./xmlns:INTERNAL-BEHAVIORS/xmlns:BSW-INTERNAL-BEHAVIOR", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             behavior = parent.createBswInternalBehavior(short_name)
             self.logger.debug("readBswInternalBehavior %s" % behavior.full_name)
 
             # read the internal behavior
             self.readInternalBehavior(child_element, behavior)
-
             self.readBswCalledEntity(child_element, behavior)
             self.readBswSchedulableEntity(child_element, behavior)
             self.readBswModeSwitchEvent(child_element, behavior)
             self.readBswTimingEvent(child_element, behavior)
             self.readBswDataReceivedEvent(child_element, behavior)
             self.readBswInternalTriggerOccurredEvent(child_element, behavior)
+            self.readBswInternalBehaviorModeSenderPolicy(child_element, behavior)
+            for group_set in self.getIncludedModeDeclarationGroupSets(child_element):
+                behavior.addIncludedModeDeclarationGroupSet(group_set)
 
     def readBswModuleDescription(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:BSW-MODULE-DESCRIPTION", self.nsmap):
-            short_name = self.readShortName(child_element)
-            bsw_module_description = parent.createBswModuleDescription(short_name)
-            bsw_module_description.module_id = self.readChildElementNumberValue(short_name, child_element, "MODULE-ID")
+        short_name = self.getShortName(element)
+        bsw_module_description = parent.createBswModuleDescription(short_name)
+        bsw_module_description.module_id = self.getChildElementOptionalNumericalValue(element, "MODULE-ID")
 
-            self.logger.debug("readBswModuleDescription %s" % bsw_module_description.full_name)
+        self.logger.debug("readBswModuleDescription %s" % bsw_module_description.full_name)
 
-            self.readBswModuleDescriptionImplementedEntry(child_element, bsw_module_description)
-            self.readProvidedModeGroup(child_element, bsw_module_description)
-            self.readRequiredModeGroup(child_element, bsw_module_description)
-            self.readBswInternalBehavior(child_element, bsw_module_description)
+        self.readBswModuleDescriptionImplementedEntry(element, bsw_module_description)
+        self.readProvidedModeGroup(element, bsw_module_description)
+        self.readRequiredModeGroup(element, bsw_module_description)
+        self.readBswInternalBehavior(element, bsw_module_description)
 
     def readBswModuleEntry(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:BSW-MODULE-ENTRY", self.nsmap):
-            short_name = self.readShortName(child_element)
-            entry = parent.createBswModuleEntry(short_name)
-            entry.is_reentrant = self.readChildOptionalElementBooleanValue(child_element, "IS-REENTRANT")
-            entry.is_synchronous = self.readChildOptionalElementBooleanValue(child_element, "IS-SYNCHRONOUS")
-            entry.service_id = self.readChildOptionalElementNumberValue(child_element, "SERVICE-ID")
-            entry.call_type = self.readChildOptionalElement(child_element, "CALL-TYPE")
-            entry.execution_context = self.readChildOptionalElement(child_element, "EXECUTION-CONTEXT")
-            entry.sw_service_impl_policy = self.readChildOptionalElement(child_element, "SW-SERVICE-IMPL-POLICY")
-
-            #self.logger.debug("readBswModuleEntry \n%s" % entry)
-            self.logger.debug("readBswModuleEntry %s" % entry.short_name)
+        short_name = self.getShortName(element)
+        entry = parent.createBswModuleEntry(short_name)
+        entry.is_reentrant = self.getChildElementOptionalBooleanValue(element, "IS-REENTRANT")
+        entry.is_synchronous = self.getChildElementOptionalBooleanValue(element, "IS-SYNCHRONOUS")
+        entry.service_id = self.getChildElementOptionalNumericalValue(element, "SERVICE-ID")
+        entry.call_type = self.getChildElementOptionalLiteral(element, "CALL-TYPE")
+        entry.execution_context = self.getChildElementOptionalLiteral(element, "EXECUTION-CONTEXT")
+        entry.sw_service_impl_policy = self.getChildElementOptionalLiteral(element, "SW-SERVICE-IMPL-POLICY")
+
+        #self.logger.debug("readBswModuleEntry \n%s" % entry)
+        self.logger.debug("readBswModuleEntry %s" % entry.short_name)
+
+    def readEngineeringObject(self, element: ET.Element, engineering_obj: EngineeringObject):
+        self.readElementAttributes(element, engineering_obj)
+        engineering_obj.setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL")) \
+                       .setCategory(self.getChildElementOptionalLiteral(element, "CATEGORY"))
+        
+    def getAutosarEngineeringObject(self, element: ET.Element) -> AutosarEngineeringObject:
+        obj = AutosarEngineeringObject()
+        self.readEngineeringObject(element, obj)
+        self.logger.debug("getAutosarEngineeringObject %s", obj.short_label)
+        return obj
 
     def readArtifactDescriptor(self, element: ET.Element, code_desc: Code):
-        for child_element in element.findall("./xmlns:ARTIFACT-DESCRIPTORS/xmlns:AUTOSAR-ENGINEERING-OBJECT", self.nsmap):
-            artifact_desc = AutosarEngineeringObject()
-            artifact_desc.short_label = self.readChildElement(code_desc.short_name, child_element, "SHORT-LABEL")
-            self.readIdentifiable(child_element, artifact_desc)
-            code_desc.addArtifactDescriptor(artifact_desc)
+        for child_element in element.findall("./xmlns:ARTIFACT-DESCRIPTORS/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if tag_name == "AUTOSAR-ENGINEERING-OBJECT":
+                code_desc.addArtifactDescriptor(self.getAutosarEngineeringObject(child_element))
+            else:
+                self._raiseError("Unsupported Artifact Descriptor <%s>" % tag_name)
             
-            self.logger.debug("readArtifactDescriptor %s", artifact_desc.short_label)
-
     def readCodeDescriptor(self, element: ET.Element, impl: Implementation):
         for child_element in element.findall("./xmlns:CODE-DESCRIPTORS/xmlns:CODE", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readCodeDescriptor %s" % short_name)
             code_desc = impl.createCodeDescriptor(short_name)
+            self.readIdentifiable(child_element, code_desc)
             self.readArtifactDescriptor(child_element, code_desc)
 
+    def readMemorySectionOptions(self, element: ET.Element, section: MemorySection):
+        child_element = element.find("./xmlns:OPTIONS", self.nsmap)
+        if child_element is not None:
+            for value in self.getChildElementLiteralValueList(child_element, "OPTION"):
+                section.addOption(value)
+
     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.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             memory_section = consumption.createMemorySection(short_name)
-            alignment = self.readChildOptionalElement(child_element, "ALIGNMENT")
-            if (alignment != None):
-                memory_section.alignment = alignment
-            memory_section.sw_addr_method_ref = self.readChildRefElement(consumption.short_name, child_element, "SW-ADDRMETHOD-REF")
+            self.readIdentifiable(child_element, memory_section)
+            memory_section.alignment = self.getChildElementOptionalLiteral(child_element, "ALIGNMENT")
+            self.readMemorySectionOptions(child_element, memory_section)
+            memory_section.size = self.getChildElementOptionalNumericalValue(child_element, "SIZE")
+            memory_section.swAddrMethodRef = self.getChildElementOptionalRefType(child_element, "SW-ADDRMETHOD-REF")
+            memory_section.symbol = self.getChildElementOptionalLiteral(child_element, "SYMBOL")
             self.logger.debug("readMemorySections %s" % memory_section.short_name)
 
     def readResourceConsumption(self, element: ET.Element, impl: Implementation):
         child_element = element.find("./xmlns:RESOURCE-CONSUMPTION", self.nsmap)
-        if (child_element == None):
-            self._raiseError("Invalid ResourceConsumption of Implementation <%s>" % impl.short_name)
-            return
-        short_name = self.readShortName(child_element)
-        impl.resource_consumption = ResourceConsumption(impl, short_name)
-        self.readMemorySections(child_element, impl.resource_consumption)
+        if (child_element is not None):
+            short_name = self.getShortName(child_element)
+            consumption = ResourceConsumption(impl, short_name)
+            self.readIdentifiable(child_element, consumption)
+            self.readMemorySections(child_element, consumption)
+            impl.setResourceConsumption(consumption)
 
     def readImplementation(self, element: ET.Element, impl: Implementation):
+        self.readIdentifiable(element, impl)
         self.readCodeDescriptor(element, impl)
-        impl.programming_language = self.readChildOptionalElement(element, "PROGRAMMING-LANGUAGE")
+        impl.programming_language = self.getChildElementOptionalLiteral(element, "PROGRAMMING-LANGUAGE")
         self.readResourceConsumption(element, impl)
-        impl.sw_version = self.readChildOptionalElement(element, "SW-VERSION")
-        impl.swc_bsw_mapping_ref = self.readChildOptionalRefElement(element, "SWC-BSW-MAPPING-REF")
-        impl.vendor_id = self.readChildOptionalElementNumberValue(element, "VENDOR-ID")
+        impl.sw_version = self.getChildElementOptionalLiteral(element, "SW-VERSION")
+        impl.swc_bsw_mapping_ref = self.getChildElementOptionalRefType(element, "SWC-BSW-MAPPING-REF")
+        impl.used_code_generator = self.getChildElementOptionalLiteral(element, "USED-CODE-GENERATOR")
+        impl.vendor_id = self.getChildElementOptionalNumericalValue(element, "VENDOR-ID")
 
-    def readBswImplementation(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:BSW-IMPLEMENTATION", self.nsmap):
-            short_name = self.readShortName(child_element)
-            impl = parent.createBswImplementation(short_name)   
-            self.logger.debug("readBswImplementation %s" % impl.short_name)
-
-            self.readImplementation(child_element, impl)
+    def readBswImplementationVendorSpecificModuleDefRefs(self, element: ET.Element, parent: BswImplementation):
+        child_element = element.find("./xmlns:VENDOR-SPECIFIC-MODULE-DEF-REFS", self.nsmap)
+        if child_element is not None:
+            for ref in self.getChildElementRefTypeList(child_element, "./VENDOR-SPECIFIC-MODULE-DEF-REF"):
+                parent.addVendorSpecificModuleDefRef(ref)
 
-            impl.ar_release_version = self.readChildElement(parent.short_name, child_element, "AR-RELEASE-VERSION")
-            impl.behavior_ref = self.readChildRefElement(parent.short_name, child_element, "BEHAVIOR-REF")
+    def readBswImplementation(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        impl = parent.createBswImplementation(short_name)   
+        self.logger.debug("readBswImplementation %s" % impl.short_name)
+        self.readImplementation(element, impl)
+        impl.ar_release_version = self.getChildElementOptionalLiteral(element, "AR-RELEASE-VERSION")
+        impl.behavior_ref = self.getChildElementOptionalRefType(element, "BEHAVIOR-REF")
+        self.readBswImplementationVendorSpecificModuleDefRefs(element, impl)
 
     def readSwcImplementation(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:SWC-IMPLEMENTATION", self.nsmap):
-            short_name = self.readShortName(child_element)
-            impl = parent.createSwcImplementation(short_name)   
-            self.logger.debug("readSwcImplementation %s" % impl.short_name)
-
-            self.readImplementation(child_element, impl)
-
-            impl.behavior_ref = self.readChildRefElement(parent.short_name, child_element, "BEHAVIOR-REF")
+        short_name = self.getShortName(element)
+        impl = parent.createSwcImplementation(short_name)   
+        self.logger.debug("readSwcImplementation %s" % impl.short_name)
+        self.readImplementation(element, impl)
+        impl.behavior_ref = self.getChildElementOptionalRefType(element, "BEHAVIOR-REF")
 
     def readDataReceivePointByArguments(self, element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-RECEIVE-POINT-BY-ARGUMENTS")
@@ -513,470 +580,658 @@ class ARXMLParser:
     def readDataReadAccesses(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-READ-ACCESSS")
 
+    def readDataWriteAccesses(self, element: ET.Element, parent: RunnableEntity):
+        self._readVariableAccesses(element, parent, "DATA-WRITE-ACCESSS")
+
     def readDataSendPoints(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-SEND-POINTS")
 
+    def getAutosarParameterRef(self, element: ET.Element, key: str) -> AutosarParameterRef:
+        accessed_parameter = None
+        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        if child_element is not None:
+            accessed_parameter = AutosarParameterRef()
+            accessed_parameter.local_parameter_ref = self.getChildElementOptionalRefType(child_element, "LOCAL-PARAMETER-REF")
+        return accessed_parameter
+
+    def readParameterAccesses(self, element: ET.Element, parent: RunnableEntity):
+        for child_element in element.findall("./xmlns:PARAMETER-ACCESSS/xmlns:PARAMETER-ACCESS", self.nsmap):
+            short_name = self.getShortName(child_element)
+            self.logger.debug("readParameterAccesses %s" % short_name)
+            parameter_access = parent.createParameterAccess(short_name)
+            parameter_access.accessed_parameter = self.getAutosarParameterRef(child_element, "ACCESSED-PARAMETER")
+
     def readWrittenLocalVariables(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "WRITTEN-LOCAL-VARIABLES")
 
     def readReadLocalVariables(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "READ-LOCAL-VARIABLES")
 
-    def readROperationIRef(self, element: ET.Element, parent: ServerCallPoint):
-        child_element = element.find("./xmlns:OPERATION-IREF", self.nsmap)
-        if (child_element != None):
+    def readROperationIRef(self, element: ET.Element, key: str, parent: ServerCallPoint):
+        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        if (child_element is not None):
             operation_iref = ROperationInAtomicSwcInstanceRef()
-            operation_iref.context_r_port_ref = self.readChildOptionalRefElement(child_element, "CONTEXT-R-PORT-REF")
-            operation_iref.target_required_operation_ref = self.readChildRefElement("", child_element, "TARGET-REQUIRED-OPERATION-REF")
+            operation_iref.context_r_port_ref = self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")
+            operation_iref.target_required_operation_ref = self.getChildElementOptionalRefType(child_element, "TARGET-REQUIRED-OPERATION-REF")
             parent.operation_iref = operation_iref
 
     def readRVariableInAtomicSwcInstanceRef(self, element: ET.Element, parent: DataReceivedEvent):
-        child_element = element.find("./xmlns:DATA-IRE", self.nsmap)
-        if (child_element != None):
+        child_element = self.find(element, "DATA-IREF")
+        if (child_element is not None):
             data_iref = RVariableInAtomicSwcInstanceRef()
-            data_iref.context_r_port_ref = self.readChildOptionalRefElement(child_element, "CONTEXT-R-PORT-REF")
-            data_iref.target_required_operation_ref = self.readChildRefElement("", child_element, "TARGET-DATA-ELEMENT-REF")
+            data_iref.context_r_port_ref = self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")
+            data_iref.target_data_element_ref = self.getChildElementOptionalRefType(child_element, "TARGET-DATA-ELEMENT-REF")
             parent.data_iref = data_iref
 
     def readRModeInAtomicSwcInstanceRef(self, element: ET.Element, parent: SwcModeSwitchEvent):
         for child_element in element.findall("./xmlns:MODE-IREFS/xmlns:MODE-IREF", self.nsmap):
             mode_iref = RModeInAtomicSwcInstanceRef()
-            mode_iref.context_port = self.readChildOptionalRefElement(child_element, "CONTEXT-PORT-REF")
-            mode_iref.context_mode_declaration_group_prototype = self.readChildRefElement("", child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")
-            mode_iref.target_mode_declaration = self.readChildRefElement("", child_element, "TARGET-MODE-DECLARATION-REF")
+            mode_iref.context_port_ref = self.getChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF")
+            mode_iref.context_mode_declaration_group_prototype_ref = self.getChildElementRefType("", child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")
+            mode_iref.target_mode_declaration_ref = self.getChildElementRefType("", child_element, "TARGET-MODE-DECLARATION-REF")
             parent.addModeIRef(mode_iref)
 
     def readSynchronousServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
-        for child_element in element.findall("./xmlns:SERVER-CALL-POINTS/xmlns:SYNCHRONOUS-SERVER-CALL-POINT", self.nsmap):
-            short_name = self.readShortName(child_element)
-            serverCallPoint = parent.createSynchronousServerCallPoint(short_name)
-            serverCallPoint.timeout = self.readChildElement(short_name, child_element, "TIMEOUT")
-            self.readROperationIRef(child_element, serverCallPoint)
+        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.timeout = self.getChildElementOptionalFloatValue(element, "TIMEOUT")
+        self.readROperationIRef(element, "OPERATION-IREF", server_call_point)
 
     def readAsynchronousServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
-        for child_element in element.findall("./xmlns:SERVER-CALL-POINTS/xmlns:ASYNCHRONOUS-SERVER-CALL-POINT", self.nsmap):
-            short_name = self.readShortName(child_element)
-            serverCallPoint = parent.createAsynchronousServerCallPoint(short_name)
-            serverCallPoint.timeout = self.readChildElement(short_name, child_element, "TIMEOUT")
-            self.readROperationIRef(child_element, serverCallPoint)
-
-    def readInternalTriggeringPoint(self, element: ET.Element, parent: RunnableEntity):
-        for child_element in element.findall("./xmlns:INTERNAL-TRIGGERING-POINTS/xmlns:INTERNAL-TRIGGERING-POINT", self.nsmap):
-            short_name = self.readShortName(child_element)
-            point = parent.createInternalTriggeringPoint(short_name)
-            point.sw_impl_policy = self.readChildOptionalElement(child_element, "SW-IMPL-POLICY")
-
-    def readRunnableEntities(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:RUNNABLES/xmlns:RUNNABLE-ENTITY", self.nsmap):
-            short_name = self.readShortName(child_element)
-            runnable = parent.createRunnableEntity(short_name)
-            runnable.can_be_invoked_concurrently = self.readChildOptionalElement(child_element, "CAN-BE-INVOKED-CONCURRENTLY")
-            runnable.symbol = self.readChildElement(short_name, child_element, "SYMBOL")
+        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.timeout = self.getChildElementOptionalFloatValue(element, "TIMEOUT")
+        self.readROperationIRef(element, "OPERATION-IREF", server_call_point)
+
+    def readInternalBehaviorServerCallPoint(self, element: ET.Element, parent: RunnableEntity):
+        for child_element in element.findall("./xmlns:SERVER-CALL-POINTS/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if tag_name == "SYNCHRONOUS-SERVER-CALL-POINT":
+                self.readSynchronousServerCallPoint(child_element, parent)
+            elif tag_name == "ASYNCHRONOUS-SERVER-CALL-POINT":
+                self.readAsynchronousServerCallPoint(child_element, parent)
+            else:
+                self._raiseError("Unsupported server call point type <%s>" % tag_name)
 
+    def readInternalTriggeringPoints(self, element: ET.Element, parent: RunnableEntity):
+        for child_element in self.findall(element, "INTERNAL-TRIGGERING-POINTS/INTERNAL-TRIGGERING-POINT"):
+            short_name = self.getShortName(child_element)
+            point = parent.createInternalTriggeringPoint(short_name)
+            point.sw_impl_policy = self.getChildElementOptionalLiteral(child_element, "SW-IMPL-POLICY")
+
+    def getRModeInAtomicSwcInstanceRef(self, element: ET.Element) -> RModeInAtomicSwcInstanceRef:
+        iref = RModeInAtomicSwcInstanceRef()
+        iref.base_ref = self.getChildElementOptionalRefType(element, "BASE")
+        iref.context_port_ref = self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")
+        iref.context_mode_declaration_group_prototype_ref = self.getChildElementOptionalRefType(element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")
+        iref.target_mode_declaration_ref = self.getChildElementOptionalRefType(element, "TARGET-MODE-DECLARATION-REF")
+        return iref
+    
+    def getRModeGroupInAtomicSWCInstanceRef(self, element: ET.Element) -> RModeGroupInAtomicSWCInstanceRef:
+        child_element = self.find(element, "MODE-GROUP-IREF/R-MODE-GROUP-IN-ATOMIC-SWC-INSTANCE-REF")
+        iref = None
+        if child_element is not None:
+            iref = RModeGroupInAtomicSWCInstanceRef()
+            iref.contextRPort = self.getChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF")
+            iref.targetModeGroup = self.getChildElementOptionalRefType(child_element, "TARGET-MODE-GROUP-REF")
+        return iref
+
+    def readModeAccessPoints(self, element: ET.Element, parent: RunnableEntity):
+        for child_element in self.findall(element, "MODE-ACCESS-POINTS/MODE-ACCESS-POINT"):
+            point = ModeAccessPoint()
+            point.modeGroupIRef = self.getRModeGroupInAtomicSWCInstanceRef(child_element)
+            parent.addModeAccessPoint(point)
+
+    def readSwcInternalBehaviorRunnables(self, element: ET.Element, parent: SwcInternalBehavior):
+        for child_element in self.findall(element, "RUNNABLES/RUNNABLE-ENTITY"):
+            short_name = self.getShortName(child_element)
+            entity = parent.createRunnableEntity(short_name)
             self.logger.debug("readRunnableEntities %s" % short_name)
-
-            self.readDataReceivePointByArguments(child_element, runnable)
-            self.readDataReceivePointByValues(child_element, runnable)
-            self.readDataReadAccesses(child_element, runnable)
-            self.readDataSendPoints(child_element, runnable)
-            self.readWrittenLocalVariables(child_element, runnable)
-            self.readReadLocalVariables(child_element, runnable)
-            self.readSynchronousServerCallPoint(child_element, runnable)
-            self.readAsynchronousServerCallPoint(child_element, runnable)
-            self.readInternalTriggeringPoint(child_element, runnable)
+            
+            self.readExecutableEntity(child_element, entity)
+            entity.canBeInvokedConcurrently = self.getChildElementOptionalBooleanValue(child_element, "CAN-BE-INVOKED-CONCURRENTLY")
+            entity.symbol = self.getChildElementOptionalLiteral(child_element, "SYMBOL")
+            entity.swAddrMethodRef = self.getChildElementOptionalRefType(child_element, "SW-ADDR-METHOD-REF")
+
+            self.readDataReceivePointByArguments(child_element, entity)
+            self.readDataReceivePointByValues(child_element, entity)
+            self.readDataReadAccesses(child_element, entity)
+            self.readDataWriteAccesses(child_element, entity)
+            self.readDataSendPoints(child_element, entity)
+            self.readParameterAccesses(child_element, entity)
+            self.readWrittenLocalVariables(child_element, entity)
+            self.readReadLocalVariables(child_element, entity)
+            self.readInternalBehaviorServerCallPoint(child_element, entity)
+            self.readInternalTriggeringPoints(child_element, entity)
+            self.readModeAccessPoints(child_element, entity)
+
+    def getRModeInAtomicSwcInstanceRef(self, element: ET.Element) -> RModeInAtomicSwcInstanceRef:
+        iref = RModeInAtomicSwcInstanceRef()
+        iref.base_ref = self.getChildElementOptionalRefType(element, "BASE")
+        iref.context_port_ref = self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")
+        iref.context_mode_declaration_group_prototype_ref = self.getChildElementOptionalRefType(element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF")
+        iref.target_mode_declaration_ref = self.getChildElementOptionalRefType(element, "TARGET-MODE-DECLARATION-REF")
+        return iref
 
     def readRTEEvent(self, element: ET.Element, event: RTEEvent):
-        event.start_on_event_ref = self.readChildOptionalRefElement(element, "START-ON-EVENT-REF")
+        self.readIdentifiable(element, event)
+        event.start_on_event_ref = self.getChildElementOptionalRefType(element, "START-ON-EVENT-REF")
+        for child_element in element.findall("./xmlns:DISABLED-MODE-IREFS/xmlns:DISABLED-MODE-IREF", self.nsmap):
+            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)
-        if (child_element != None):
+        if (child_element is not None):
             parent.operation_iref = POperationInAtomicSwcInstanceRef()
-            parent.operation_iref.context_p_port_ref = self.readChildRefElement(parent.short_name, child_element, "CONTEXT-P-PORT-REF")
-            parent.operation_iref.target_provided_operation_ref = self.readChildRefElement(parent.short_name, child_element, "TARGET-PROVIDED-OPERATION-REF")
-
-    def readOperationInvokedEvents(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:OPERATION-INVOKED-EVENT", self.nsmap):
-            short_name = self.readShortName(child_element)
-            event = parent.createOperationInvokedEvent(short_name)
-            self.readOperationIRef(child_element, event)
-            self.readRTEEvent(child_element, event)
-
+            parent.operation_iref.context_p_port_ref = self.getChildElementRefType(parent.short_name, child_element, "CONTEXT-P-PORT-REF")
+            parent.operation_iref.target_provided_operation_ref = self.getChildElementRefType(parent.short_name, child_element, "TARGET-PROVIDED-OPERATION-REF")
+
+    def readOperationInvokedEvent(self, element: ET.Element, parent: SwcInternalBehavior):
+        short_name = self.getShortName(element)
+        event = parent.createOperationInvokedEvent(short_name)
+        self.readOperationIRef(element, event)
+        self.readRTEEvent(element, event)
+    
     def readExplicitInterRunnableVariables(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in element.findall("./xmlns:EXPLICIT-INTER-RUNNABLE-VARIABLES/xmlns:VARIABLE-DATA-PROTOTYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             prototype = parent.createExplicitInterRunnableVariable(short_name)
-            self.readSwDataDefProps(child_element, prototype)
-            prototype.type_tref = self.readChildRefElement(parent.short_name, child_element, "TYPE-TREF")
-
-    def readInitEvents(self, element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:INIT-EVENT", self.nsmap):
-            short_name = self.readShortName(child_element)
-            event = parent.createInitEvent(short_name)
-
-            self.readRTEEvent(child_element, event)
-
-    def readTimingEvents(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:TIMING-EVENT", self.nsmap):
-            short_name = self.readShortName(child_element)
-            event = parent.createTimingEvent(short_name)
-
-            self.readRTEEvent(child_element, event)
-
-            offset = self.readChildOptionalElement(child_element, "OFFSET")
-            if (offset != None):
-                event.offset = (float)(offset)
-            event.period = (float)(self.readChildElement(short_name, child_element, "PERIOD"))
+            prototype.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
+            prototype.type_tref = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
+            prototype.init_value = self.getInitValue(child_element)
+
+    def readPerInstanceMemories(self, element: ET.Element, behavior: SwcInternalBehavior):
+        for child_element in element.findall("./xmlns:PER-INSTANCE-MEMORYS/xmlns:PER-INSTANCE-MEMORY", self.nsmap):
+            short_name = self.getShortName(child_element)
+            memory = behavior.createPerInstanceMemory(short_name)
+            self.readIdentifiable(child_element, memory)
+            memory.init_value = self.getChildElementOptionalLiteral(child_element, "INIT-VALUE")
+            memory.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
+            memory.type = self.getChildElementOptionalLiteral(child_element, "TYPE")
+            memory.type_definition = self.getChildElementOptionalLiteral(child_element, "TYPE-DEFINITION")
+
+    def readAutosarDataPrototype(self, element: ET.Element, prototype: AutosarDataPrototype):
+        prototype.type_tref = self.getChildElementOptionalRefType(element, "TYPE-TREF")
+
+    def readParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
+        self.readIdentifiable(element, prototype)
+        self.readAutosarDataPrototype(element, prototype)
+        prototype.init_value = self.getInitValue(element)
+        
+    def readPerInstanceParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
+        for child_element in element.findall("./xmlns:PER-INSTANCE-PARAMETERS/xmlns:PARAMETER-DATA-PROTOTYPE", self.nsmap):
+            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)
+        if child_element is not None:
+            argument_value.value = self.getValueSpecification(child_element)
+        argument_value.value_type = 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):
+            option = PortAPIOption()
+            option.enable_take_address = self.getChildElementOptionalBooleanValue(child_element, "ENABLE-TAKE-ADDRESS")
+            option.indirect_api = self.getChildElementOptionalBooleanValue(child_element, "INDIRECT-API")
+            option.port_ref = 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):
+                option.addPortArgValue(self.readPortDefinedArgumentValue(argument_value_tag))
+            behavior.addPortAPIOption(option)
+            
+    def readTimingEvent(self, element: ET.Element, parent: SwcInternalBehavior):
+        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")
 
     def readDataReceivedEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:DATA-RECEIVED-EVENT", self.nsmap):
-            short_name = self.readShortName(child_element)
-            event = parent.createDataReceivedEvent(short_name)
-
-            self.readRTEEvent(child_element, event)
-            self.readRVariableInAtomicSwcInstanceRef(child_element, event)
+        short_name = self.getShortName(element)
+        event = parent.createDataReceivedEvent(short_name)
+        self.readRTEEvent(element, event)
+        self.readRVariableInAtomicSwcInstanceRef(element, event)
 
     def readSwcModeSwitchEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:SWC-MODE-SWITCH-EVENT", self.nsmap):
-            short_name = self.readShortName(child_element)
-            event = parent.createSwcModeSwitchEvent(short_name)
-
-            self.readRTEEvent(child_element, event)
-            self.readRModeInAtomicSwcInstanceRef(child_element, event)
+        short_name = self.getShortName(element)
+        event = parent.createSwcModeSwitchEvent(short_name)
+        self.readRTEEvent(element, event)
+        event.activation = self.getChildElementOptionalLiteral(element, "ACTIVATION")
+        self.readRModeInAtomicSwcInstanceRef(element, event)
 
     def readInternalTriggerOccurredEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        for child_element in element.findall("./xmlns:EVENTS/xmlns:INTERNAL-TRIGGER-OCCURRED-EVENT", self.nsmap):
-            short_name = self.readShortName(child_element)
-            event = parent.createInternalTriggerOccurredEvent(short_name)
-
-            self.readRTEEvent(child_element, event)
-            event.event_source_ref = self.readChildRefElement(parent.short_name, child_element, "EVENT-SOURCE-REF")
-
-    def readSwPointerTargetProps(self, element: ET.Element, parent: ARElement):
-        child_element = element.find(
-            "./xmlns:SW-POINTER-TARGET-PROPS", self.nsmap)
+        short_name = self.getShortName(element)
+        event = parent.createInternalTriggerOccurredEvent(short_name)
+        self.readRTEEvent(element, event)
+        event.event_source_ref = self.getChildElementRefType(parent.short_name, element, "EVENT-SOURCE-REF")
+
+    def readInitEvent(self, element, parent: SwcInternalBehavior):
+        short_name = self.getShortName(element)
+        event = parent.createInitEvent(short_name)
+        self.readRTEEvent(element, event)
+
+    def readSwcInternalBehaviorEvents(self, element: ET.Element, parent: SwcInternalBehavior):
+        for child_element in element.findall("./xmlns:EVENTS/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if tag_name == "TIMING-EVENT":
+                self.readTimingEvent(child_element, parent)
+            elif tag_name == "SWC-MODE-SWITCH-EVENT":
+                self.readSwcModeSwitchEvent(child_element, parent)
+            elif tag_name == "OPERATION-INVOKED-EVENT":
+                self.readOperationInvokedEvent(child_element, parent)
+            elif tag_name == "DATA-RECEIVED-EVENT":
+                self.readDataReceivedEvent(child_element, parent)
+            elif tag_name == "INTERNAL-TRIGGER-OCCURRED-EVENT":
+                self.readInternalTriggerOccurredEvent(child_element, parent)
+            elif tag_name == "INIT-EVENT":
+                self.readInitEvent(child_element, parent)
+            else:
+                self._raiseError("Unsupported SwcInternalBehavior Event <%s>" % tag_name)
 
-        if (child_element != None):
+    def readSwPointerTargetProps(self, element: ET.Element, parent: SwDataDefProps):
+        child_element = element.find("./xmlns:SW-POINTER-TARGET-PROPS", self.nsmap)
+        if (child_element is not None):
             sw_pointer_target_props = SwPointerTargetProps()
-            sw_pointer_target_props.target_category = self.readChildElement("", child_element, "TARGET-CATEGORY")
-            self.readSwDataDefProps(child_element, sw_pointer_target_props)
+            sw_pointer_target_props.target_category = self.getChildElementOptionalLiteral(child_element, "TARGET-CATEGORY")
+            sw_pointer_target_props.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
             parent.sw_pointer_target_props = sw_pointer_target_props
 
-    def parseSwDataDefProps(self, element: ET.Element) -> SwDataDefProps:
-        child_element = element.find("./xmlns:SW-DATA-DEF-PROPS/xmlns:SW-DATA-DEF-PROPS-VARIANTS/xmlns:SW-DATA-DEF-PROPS-CONDITIONAL", self.nsmap)
-
-        if (child_element != None):
-            sw_data_def_props = SwDataDefProps()
-            sw_data_def_props.base_type_ref = self.readChildOptionalRefElement(child_element, "BASE-TYPE-REF")
-            sw_data_def_props.data_constr_ref = self.readChildOptionalRefElement(child_element, "DATA-CONSTR-REF")
-            sw_data_def_props.compu_method_ref = self.readChildOptionalRefElement(child_element, "COMPU-METHOD-REF")
-            sw_data_def_props.implementation_data_type_ref = self.readChildOptionalRefElement(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
-            sw_data_def_props.sw_calibration_access = self.readChildOptionalElement(child_element, "SW-CALIBRATION-ACCESS")
-            self.readSwPointerTargetProps(child_element, sw_data_def_props)
-            return sw_data_def_props
-
-    def readSwDataDefProps(self, element: ET.Element, parent: AutosarDataType):
-        child_element = element.find("./xmlns:SW-DATA-DEF-PROPS/xmlns:SW-DATA-DEF-PROPS-VARIANTS/xmlns:SW-DATA-DEF-PROPS-CONDITIONAL", self.nsmap)
-
-        if (child_element != None):
-            sw_data_def_props = SwDataDefProps()
-            sw_data_def_props.base_type_ref = self.readChildOptionalRefElement(child_element, "BASE-TYPE-REF")
-            sw_data_def_props.data_constr_ref = self.readChildOptionalRefElement(child_element, "DATA-CONSTR-REF")
-            sw_data_def_props.compu_method_ref = self.readChildOptionalRefElement(child_element, "COMPU-METHOD-REF")
-            sw_data_def_props.implementation_data_type_ref = self.readChildOptionalRefElement(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
-            sw_data_def_props.sw_calibration_access = self.readChildOptionalElement(child_element, "SW-CALIBRATION-ACCESS")
-            self.readSwPointerTargetProps(child_element, sw_data_def_props)
-            parent.sw_data_def_props = sw_data_def_props
-
-    def readApplicationPrimitiveDataTypes(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:APPLICATION-PRIMITIVE-DATA-TYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            data_type = parent.createApplicationPrimitiveDataType(short_name)
-            self.logger.debug("readApplicationPrimitiveDataTypes %s" % short_name)
-            self.readIdentifiable(child_element, data_type)
-            self.readSwDataDefProps(child_element, data_type)
+    def readGeneralAnnotation(self, element: ET.Element, annotation: GeneralAnnotation):
+        annotation.label = self.getMultilanguageLongName(element, "LABEL")
+
+    def readAnnotations(self, element: ET.Element, props: SwDataDefProps) :
+        for child_element in element.findall("./xmlns:ANNOTATIONS/xmlns:ANNOTATION", self.nsmap):
+            annotation = Annotation()
+            self.readGeneralAnnotation(child_element, annotation)
+            props.addAnnotation(annotation)
+
+    def getSwAxisIndividual(self, element: ET.Element) -> SwAxisIndividual:
+        props = SwAxisIndividual()
+        self.readElementAttributes(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")) \
+             .setSwMinAxisPoints(self.getChildElementOptionalNumericalValue(element, "SW-MIN-AXIS-POINTS")) \
+             .setDataConstrRef(self.getChildElementOptionalRefType(element, "DATA-CONSTR-REF"))
+        return props
+    
+    def getSwAxisGrouped(self, element: ET.Element) -> SwAxisGrouped:
+        props = SwAxisGrouped()
+        props.setSharedAxisTypeRef(self.getChildElementOptionalRefType(element, "SHARED-AXIS-TYPE-REF"))
+        return props
+
+    def getSwCalprmAxis(self, element: ET.Element) -> SwCalprmAxis:
+        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)
+        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)
+        if child_element is not None:
+            axis.sw_calprm_axis_type_props = self.getSwAxisGrouped(child_element)
+        
+        return axis
+
+    def getSwCalprmAxisSet(self, element: ET.Element, key: str) -> SwCalprmAxisSet:
+        set = SwCalprmAxisSet()
+        for child_element in element.findall("./xmlns:%s/*" % key, self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if tag_name == "SW-CALPRM-AXIS":
+                set.addSwCalprmAxis(self.getSwCalprmAxis(child_element))
+        return set
+
+    def getSwDataDefProps(self, element: ET.Element, key: str) -> SwDataDefProps:
+        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        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)
+            if conditional_tag is not None:
+                sw_data_def_props = SwDataDefProps()
+                self.readElementAttributes(child_element, sw_data_def_props)
+
+                self.readAnnotations(conditional_tag, sw_data_def_props)
+                sw_data_def_props.baseTypeRef = self.getChildElementOptionalRefType(conditional_tag, "BASE-TYPE-REF")
+                sw_data_def_props.dataConstrRef = self.getChildElementOptionalRefType(conditional_tag, "DATA-CONSTR-REF")
+                sw_data_def_props.compuMethodRef = self.getChildElementOptionalRefType(conditional_tag, "COMPU-METHOD-REF")
+                sw_data_def_props.swImplPolicy = self.getChildElementOptionalLiteral(conditional_tag, "SW-IMPL-POLICY")
+                sw_data_def_props.implementationDataTypeRef = self.getChildElementOptionalRefType(conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF")
+                sw_data_def_props.swCalibrationAccess = self.getChildElementOptionalLiteral(conditional_tag, "SW-CALIBRATION-ACCESS")
+                sw_data_def_props.swCalprmAxisSet = self.getSwCalprmAxisSet(conditional_tag, "SW-CALPRM-AXIS-SET")
+                sw_data_def_props.swRecordLayoutRef = self.getChildElementOptionalRefType(conditional_tag, "SW-RECORD-LAYOUT-REF")
+                sw_data_def_props.valueAxisDataTypeRef = self.getChildElementOptionalRefType(conditional_tag, "VALUE-AXIS-DATA-TYPE-REF")
+                sw_data_def_props.setUnitRef(self.getChildElementOptionalRefType(conditional_tag, "UNIT-REF"))
+                self.readSwPointerTargetProps(conditional_tag, sw_data_def_props)
+                self.readElementAttributes(conditional_tag, sw_data_def_props.conditional)
+        return sw_data_def_props
+
+    def readApplicationPrimitiveDataType(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        data_type = parent.createApplicationPrimitiveDataType(short_name)
+        self.logger.debug("readApplicationPrimitiveDataTypes %s" % short_name)
+        self.readIdentifiable(element, data_type)
+        data_type.sw_data_def_props = self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS")
+
+    def readApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
+        prototype.typeTRef = 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):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             record_element = parent.createApplicationRecordElement(short_name)
             self.logger.debug("readApplicationRecordElements %s" % short_name)
             self.readIdentifiable(child_element, record_element)
-            record_element.type_tref = self.readChildOptionalRefElement(child_element, "TYPE-TREF")
+            self.readApplicationCompositeElementDataPrototype(child_element, record_element)
 
     def readApplicationRecordDataTypes(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:APPLICATION-RECORD-DATA-TYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            data_type = parent.createApplicationRecordDataType(short_name)
-            self.logger.debug("readApplicationRecordDataTypes %s" % short_name)
-            self.readIdentifiable(child_element, data_type)
-            self.readSwDataDefProps(child_element, data_type)
-            self.readApplicationRecordElements(child_element, data_type)
-
-    def readImplementationDataTypeElements(self, element: ET.Element, parent: ARElement):
+        short_name = self.getShortName(element)
+        data_type = parent.createApplicationRecordDataType(short_name)
+        self.logger.debug("readApplicationRecordDataTypes %s" % short_name)
+        self.readIdentifiable(element, data_type)
+        data_type.sw_data_def_props = self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS")
+        self.readApplicationRecordElements(element, data_type)
+
+    def readImplementationDataTypeElements(self, element: ET.Element, parent: ImplementationDataType):
         for child_element in element.findall("./xmlns:SUB-ELEMENTS/xmlns:IMPLEMENTATION-DATA-TYPE-ELEMENT", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             type_element = parent.createImplementationDataTypeElement(short_name)   # type: ImplementationDataTypeElement
             self.readIdentifiable(child_element, type_element)
-            type_element.array_size = self.readChildOptionalElement(child_element, "ARRAY-SIZE")
-            type_element.array_size_semantics = self.readChildOptionalElement(child_element, "ARRAY-SIZE-SEMANTICS")
+            type_element.arraySize = self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE")
+            type_element.array_size_semantics = self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS")
             self.readImplementationDataTypeElements(child_element, type_element)
-            self.readSwDataDefProps(child_element, type_element)
-
-    def readImplementationDataTypes(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:IMPLEMENTATION-DATA-TYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            data_type = parent.createImplementationDataType(short_name)
-            self.readIdentifiable(child_element, data_type)
-            self.readImplementationDataTypeElements(child_element, data_type)
-            self.readSwDataDefProps(child_element, data_type)
-            if (data_type.category == ImplementationDataType.CATEGORY_ARRAY):
-                if (len(data_type.getImplementationDataTypeElements()) < 1):
-                    self._raiseError("Array Sub-Element of <%s> do not defined." % data_type.short_name)
-                array_sub_element = data_type.getImplementationDataTypeElements()[0]
-                if (array_sub_element.category == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
-                    data_type.setArrayElementType(array_sub_element.sw_data_def_props.implementation_data_type_ref.value)
-                elif (array_sub_element.category == ImplementationDataType.CATEGORY_TYPE_VALUE):  # TODO: fix 
-                    continue
-                else:
-                    self._raiseError("The category <%s> of array sub-element <%s> does not support." % (array_sub_element.category, data_type.short_name))
-
-    def readBaseTypeDirectDefinition(self, element: ET.Element, parent: BaseType):
-        parent.base_type_definition.base_type_size = int(self.readChildOptionalElement(element, "BASE-TYPE-SIZE"))
-        parent.base_type_definition.base_type_encoding = self.readChildOptionalElementLiteral(element, "BASE-TYPE-ENCODING")
-        parent.base_type_definition.native_declaration = self.readChildOptionalElementLiteral(element, "NATIVE-DECLARATION")
-
-    def readSwBaseTypes(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:SW-BASE-TYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            data_type = parent.createSwBaseType(short_name)
-            self.readIdentifiable(child_element, data_type)
-            self.readBaseTypeDirectDefinition(child_element, data_type)
-
-    def readClientComSpec(self, element: ET.Element, parent: RPortPrototype):
-        for child_element in element.findall("./xmlns:REQUIRED-COM-SPECS/xmlns:CLIENT-COM-SPEC", self.nsmap):
-            try:
-                com_spec = ClientComSpec()
-                self.readElementAttributes(child_element, com_spec)
-                com_spec.operation_ref = self.readChildRefElement(parent.short_name, child_element, "OPERATION-REF")
-                parent.addRequiredComSpec(com_spec)
-            except ValueError as err:
-                self.logger.error(parent.short_name + ": " + str(err))
+            type_element.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
+
+    def readImplementationDataType(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        data_type = parent.createImplementationDataType(short_name)
+        self.readAutosarDataType(element, data_type)
+        self.readImplementationDataTypeElements(element, data_type)
+        data_type.setTypeEmitter(self.getChildElementOptionalLiteral(element, "TYPE-EMITTER"))
+        if (data_type.category == ImplementationDataType.CATEGORY_ARRAY):
+            if (len(data_type.getImplementationDataTypeElements()) < 1):
+                self._raiseError("Array Sub-Element of <%s> do not defined." % data_type.short_name)
+            array_sub_element = data_type.getImplementationDataTypeElements()[0]
+            if (array_sub_element.category == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
+                data_type.setArrayElementType(array_sub_element.sw_data_def_props.implementationDataTypeRef.value)
+            elif (array_sub_element.category == ImplementationDataType.CATEGORY_TYPE_VALUE):  # TODO: fix 
+                return
+            else:
+                self._raiseError("The category <%s> of array sub-element <%s> does not support." % (array_sub_element.category, data_type.short_name))
 
-    def readReceiverComSpec(self, element, com_spec: ReceiverComSpec):
-        #FIXME: readchildElement
-        com_spec.data_element_ref = self.readChildOptionalRefElement(element, "DATA-ELEMENT-REF")
-        self.readSwDataDefProps(element, com_spec)
-        com_spec.handle_out_of_range = self.readChildOptionalElement(element, "HANDLE-OUT-OF-RANGE")
-        com_spec.uses_end_to_end_protection = self.readChildOptionalElementBooleanValue(element, "USES-END-TO-END-PROTECTION")
+    def readBaseTypeDirectDefinition(self, element: ET.Element, definition: BaseTypeDirectDefinition):
+        definition.base_type_size = self.getChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE")
+        definition.base_type_encoding = self.getChildElementOptionalLiteral(element, "BASE-TYPE-ENCODING")
+        definition.mem_alignment = self.getChildElementOptionalNumericalValue(element, "MEM-ALIGNMENT")
+        definition.native_declaration = self.getChildElementOptionalLiteral(element, "NATIVE-DECLARATION")
+
+    def readSwBaseType(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        data_type = parent.createSwBaseType(short_name)
+        self.readIdentifiable(element, data_type)
+        self.readBaseTypeDirectDefinition(element, data_type.baseTypeDefinition)
 
-    def readSwValues(self, element: ET.Element, key: str) -> SwValues:
+    def getApplicationCompositeElementInPortInterfaceInstanceRef(self, element: ET.Element, key:str) -> ApplicationCompositeElementInPortInterfaceInstanceRef:
+        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        iref = None
+        if child_element is not None:
+            iref = ApplicationCompositeElementInPortInterfaceInstanceRef()
+            iref.root_data_prototype_ref = self.getChildElementOptionalRefType(child_element, "ROOT-DATA-PROTOTYPE-REF")
+            iref.target_data_prototype_ref = self.getChildElementOptionalRefType(child_element, "TARGET-DATA-PROTOTYPE-REF")
+        return iref
+
+    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")
+        return representation
+
+    def readReceiverComSpec(self, element, com_spec: ReceiverComSpec):
+        self.readElementAttributes(element, com_spec)
+        for child_element in element.findall("./xmlns:COMPOSITE-NETWORK-REPRESENTATIONS/xmlns:COMPOSITE-NETWORK-REPRESENTATION", self.nsmap):
+            com_spec.addCompositeNetworkRepresentation(self.getCompositeNetworkRepresentation(child_element))
+        com_spec.data_element_ref = self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")
+        com_spec.network_representation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
+        com_spec.handle_out_of_range = self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE")
+        com_spec.uses_end_to_end_protection = self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION")
+
+    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
-        values = SwValues()
-        v_element = child_element.find("./xmlns:V", self.nsmap)
-        if v_element is not None:
-            values.v = v_element.text
-            self.logger.debug("readSwValues - V: %s" % values.v)
-        return values
-
-    def readSwValueCont(self, element: ET.Element) -> SwValueCont:
+        sw_values = SwValues()
+        self.readElementAttributes(child_element, sw_values)
+        for v in self.getChildElementFloatValueList(child_element, "V"):
+            sw_values.addV(v)
+        sw_values.vt = self.getChildElementOptionalLiteral(child_element, "VT")
+        return sw_values
+    
+    def getValueList(self, element: ET.Element, key: str) -> ValueList:
+        value_list = None
+        child_element = element.find("./xmlns:%s" % key, self.nsmap) # type: ET.Element
+        if child_element is not None:
+            self.logger.debug("getValueList %s" % key)
+            value_list = ValueList()
+            self.readElementAttributes(child_element, value_list)
+            value_list.v = self.getChildElementOptionalFloatValue(child_element, "V")
+        return value_list
+
+    def getSwValueCont(self, element: ET.Element) -> SwValueCont:
         cont = None
         child_element = element.find("./xmlns:SW-VALUE-CONT", self.nsmap)
         if child_element is not None:
+            self.logger.debug("getSwValueCont")
             cont = SwValueCont()
-            cont.unit_ref = self.readChildOptionalRefElement(child_element, "UNIT-REF")
-            cont.sw_values_phys = self.readSwValues(child_element, "SW-VALUES-PHYS")
-
-            self.logger.debug("readSwValueCont - Unit: %s" % cont.unit_ref.value)
+            self.readElementAttributes(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")
         return cont
     
-    def readValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
-        value_spec.short_label = self.readChildOptionalElement(element, "SHORT-LABEL")
-        self.readElementAttributes(element, value_spec)
-        
-        self.logger.debug("readValueSpecification")
-
     def readApplicationValueSpecification(self, element: ET.Element, value_spec: ApplicationValueSpecification):
         self.readValueSpecification(element, value_spec)
-        value_spec.category = self.readChildOptionalElement(element, "CATEGORY")
-        value_spec.sw_value_cont = self.readSwValueCont(element)
+        value_spec.category = self.getChildElementOptionalLiteral(element, "CATEGORY")
+        value_spec.sw_value_cont = self.getSwValueCont(element)
 
         self.logger.debug("readApplicationValueSpecification Category %s" % value_spec.category)
 
-    def readTextValueSpecification(self, element: ET.Element, value_spec: TextValueSpecification):
-        self.readValueSpecification(element, value_spec)
-        value_spec.value = self.readChildOptionalElement(element, "VALUE")
-
-        self.logger.debug("readTextValueSpecification Value: %s" % value_spec.value)
-
-    def readNumericalValueSpecification(self, element: ET.Element, value_spec: NumericalValueSpecification):
-        self.readValueSpecification(element, value_spec)
-        value_spec.value = self.readChildOptionalElement(element, "VALUE")
-
-        self.logger.debug("readNumericalValueSpecification Value: %s" % value_spec.value)
-
-    def readArrayValueSpecification(self, element: ET.Element, value_spec: ArrayValueSpecification):
-        self.readValueSpecification(element, value_spec)
-        
-        child_elements = element.findall("./xmlns:ELEMENTS/xmlns:NUMERICAL-VALUE-SPECIFICATION", self.nsmap)
-        for child_element in child_elements:
-            sub_element = NumericalValueSpecification()
-            self.readNumericalValueSpecification(child_element, sub_element)
-            value_spec.add_element(sub_element)
-
-        self.logger.debug("readArrayValueSpecification")
-
-    def readConstantReference(self, element: ET.Element, value_spec: ConstantReference):
-        self.readValueSpecification(element, value_spec)
-
-        value_spec.constant_ref = self.readChildOptionalRefElement(element, "CONSTANT-REF")
-
-    def readInitValue(self, element: ET.Element) -> ValueSpecification:
+    def getInitValue(self, element: ET.Element) -> ValueSpecification:
         value_spec = None
-        child_element = element.find("./xmlns:INIT-VALUE", self.nsmap)
+        child_element = element.find("./xmlns:INIT-VALUE/*", self.nsmap)
         if child_element is not None:
-            self.logger.debug("readInitValue")
-            value_spec_tag = child_element.find("./xmlns:APPLICATION-VALUE-SPECIFICATION", self.nsmap)
-            if value_spec_tag is not None:
-                value_spec = ApplicationValueSpecification()
-                self.readApplicationValueSpecification(value_spec_tag, value_spec)
-                return value_spec
-            value_spec_tag = child_element.find("./xmlns:TEXT-VALUE-SPECIFICATION", self.nsmap)
-            if value_spec_tag is not None:
-                value_spec = TextValueSpecification()
-                self.readTextValueSpecification(value_spec_tag, value_spec)
-                return value_spec
-            value_spec_tag = child_element.find("./xmlns:NUMERICAL-VALUE-SPECIFICATION", self.nsmap)
-            if value_spec_tag is not None:
-                value_spec = NumericalValueSpecification()
-                self.readNumericalValueSpecification(value_spec_tag, value_spec)
-                return value_spec
-            value_spec_tag = child_element.find("./xmlns:ARRAY-VALUE-SPECIFICATION", self.nsmap)
-            if value_spec_tag is not None:
-                value_spec = ArrayValueSpecification()
-                self.readArrayValueSpecification(value_spec_tag, value_spec)
-                return value_spec
-            value_spec_tag = child_element.find("./xmlns:CONSTANT-REFERENCE", self.nsmap)
-            if value_spec_tag is not None:
-                value_spec = ConstantReference()
-                self.readConstantReference(value_spec_tag, value_spec)
-                return value_spec
-
+            self.logger.debug("getInitValue")
+            value_spec = self.getValueSpecification(child_element)
         return value_spec
-
-    def readNonqueuedReceiverComSpec(self, element, parent: RPortPrototype):
-        for child_element in element.findall("./xmlns:REQUIRED-COM-SPECS/xmlns:NONQUEUED-RECEIVER-COM-SPEC", self.nsmap):
-            com_spec = NonqueuedReceiverComSpec()
-
-            self.readElementAttributes(child_element, com_spec)            
-            self.readReceiverComSpec(child_element, com_spec)
-            try:
-                # FIXME:
-                com_spec.alive_timeout = self.readChildElementFloatValue("", child_element, "ALIVE-TIMEOUT")
-                com_spec.enable_updated = self.readChildElementBooleanValue("", child_element, "ENABLE-UPDATE")
-                com_spec.handle_never_received = self.readChildElementBooleanValue("", child_element, "HANDLE-NEVER-RECEIVED")
-                com_spec.handel_timeout_type = self.readChildElement("", child_element, "HANDLE-TIMEOUT-TYPE")
-            except ValueError as err:
-                self.logger.error(parent.short_name + ": " + str(err))
-
-            com_spec.init_value = self.readInitValue(child_element)
-
-            parent.addRequiredComSpec(com_spec)
-
-    def readRPortPrototype(self, element, parent: AtomicSwComponentType):
-        for child_element in element.findall("./xmlns:PORTS/xmlns:R-PORT-PROTOTYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            self.logger.debug("readRPortPrototype %s" % short_name)
-
-            prototype = parent.createRPortPrototype(short_name)
-            self.readElementAttributes(child_element, prototype)
-            prototype.required_interface_tref = self.readChildOptionalRefElement(child_element, "REQUIRED-INTERFACE-TREF")
-
-            self.readClientComSpec(child_element, prototype)
-            self.readNonqueuedReceiverComSpec(child_element, prototype)
+    
+    def getClientComSpec(self, element: ET.Element) -> ClientComSpec:
+        com_spec = ClientComSpec()
+        self.readElementAttributes(element, com_spec)
+        com_spec.operationRef = self.getChildElementOptionalRefType(element, "OPERATION-REF")
+        return com_spec
+    
+    def getQueuedReceiverComSpec(self, element: ET.Element) -> QueuedReceiverComSpec:
+        com_spec = QueuedReceiverComSpec()
+        self.readElementAttributes(element, com_spec)
+        self.readReceiverComSpec(element, com_spec)
+        com_spec.queue_length = self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH")
+        return com_spec
+    
+    def getModeSwitchReceiverComSpec(self, element: ET.Element) -> ModeSwitchReceiverComSpec:
+        com_spec = ModeSwitchReceiverComSpec()
+        self.readElementAttributes(element, com_spec)
+        com_spec.modeGroupRef = self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")
+        return com_spec
+
+    def getNonqueuedReceiverComSpec(self, element: ET.Element) -> NonqueuedReceiverComSpec:
+        com_spec = NonqueuedReceiverComSpec()
+        self.readElementAttributes(element, com_spec)            
+        self.readReceiverComSpec(element, com_spec)
+        com_spec.alive_timeout = self.getChildElementOptionalFloatValue(element, "ALIVE-TIMEOUT")
+        com_spec.enable_updated = self.getChildElementOptionalBooleanValue(element, "ENABLE-UPDATE")
+        com_spec.handle_never_received = self.getChildElementOptionalBooleanValue(element, "HANDLE-NEVER-RECEIVED")
+        com_spec.handel_timeout_type = self.getChildElementOptionalLiteral(element, "HANDLE-TIMEOUT-TYPE")
+        com_spec.init_value = self.getInitValue(element)
+        return com_spec
+
+    def readRequiredComSpec(self, element: ET.Element, parent: RPortPrototype):
+        for child_element in element.findall("./xmlns:REQUIRED-COM-SPECS/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if tag_name == "NONQUEUED-RECEIVER-COM-SPEC":
+                parent.addRequiredComSpec(self.getNonqueuedReceiverComSpec(child_element))
+            elif tag_name == "CLIENT-COM-SPEC":
+                parent.addRequiredComSpec(self.getClientComSpec(child_element))
+            elif tag_name == "QUEUED-RECEIVER-COM-SPEC":
+                parent.addRequiredComSpec(self.getQueuedReceiverComSpec(child_element))
+            elif tag_name == "MODE-SWITCH-RECEIVER-COM-SPEC":
+                parent.addRequiredComSpec(self.getModeSwitchReceiverComSpec(child_element))
+            else:
+                self._raiseError("Unsupported RequiredComSpec <%s>" % tag_name)
+
+    def readRPortPrototype(self, element: ET.Element, parent: AtomicSwComponentType):
+        short_name = self.getShortName(element)
+        self.logger.debug("readRPortPrototype %s" % short_name)
+        prototype = parent.createRPortPrototype(short_name)
+        self.readIdentifiable(element, prototype)
+        prototype.required_interface_tref = self.getChildElementOptionalRefType(element, "REQUIRED-INTERFACE-TREF")
+
+        self.readRequiredComSpec(element, prototype)
+
+    def readAtomicSwComponentTypePorts(self, element: ET.Element, sw_component: AtomicSwComponentType):
+        for child_element in element.findall("./xmlns:PORTS/*", self.nsmap):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "P-PORT-PROTOTYPE":
+                self.readPPortPrototype(child_element, sw_component)
+            elif tag_name == "R-PORT-PROTOTYPE":
+                self.readRPortPrototype(child_element, sw_component)
+            else:
+                self._raiseError("Unsupported Port Prototype <%s>" % tag_name)
 
     def readTransmissionAcknowledgementRequest(self, element: ET.Element) -> TransmissionAcknowledgementRequest:
         child_element = element.find("./xmlns:TRANSMISSION-ACKNOWLEDGE", self.nsmap)
-        if (child_element != None):
+        if (child_element is not None):
             acknowledge = TransmissionAcknowledgementRequest()
             self.readElementAttributes(child_element, acknowledge)
-            acknowledge.timeout = self.readChildElementFloatValue ("", child_element, "TIMEOUT")
+            acknowledge.timeout = self.getChildElementOptionalFloatValue(child_element, "TIMEOUT")
             return acknowledge
         return None
 
-    def readSenderComSpec(self, element, com_spec: SenderComSpec):
-        # FIXME:
+    def readSenderComSpec(self, element:ET.Element, com_spec: SenderComSpec):
         self.readElementAttributes(element, com_spec)
-        com_spec.data_element_ref = self.readChildOptionalRefElement(element, "DATA-ELEMENT-REF")
-        com_spec.network_representation = self.parseSwDataDefProps(element)
-        self.logger.debug("network_representation %s" % com_spec.network_representation)
-        com_spec.handle_out_of_range = self.readChildOptionalElement(element, "HANDLE-OUT-OF-RANGE")
+        for child_element in element.findall("./xmlns:COMPOSITE-NETWORK-REPRESENTATIONS/xmlns:COMPOSITE-NETWORK-REPRESENTATION", self.nsmap):
+            com_spec.addCompositeNetworkRepresentation(self.getCompositeNetworkRepresentation(child_element))
+        com_spec.data_element_ref = self.getChildElementOptionalRefType(element, "DATA-ELEMENT-REF")
+        com_spec.network_representation = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION")
+        com_spec.handle_out_of_range = self.getChildElementOptionalLiteral(element, "HANDLE-OUT-OF-RANGE")
         com_spec.transmission_acknowledge = self.readTransmissionAcknowledgementRequest(element)
-        com_spec.uses_end_to_end_protection = self.readChildOptionalElementBooleanValue(element, "USES-END-TO-END-PROTECTION")
-
-    def readNonqueuedSenderComSpec(self, element, parent: PPortPrototype):
-        for child_element in element.findall("./xmlns:PROVIDED-COM-SPECS/xmlns:NONQUEUED-SENDER-COM-SPEC", self.nsmap):
-            com_spec = NonqueuedSenderComSpec()
-            self.readSenderComSpec(child_element, com_spec)
-            
-            com_spec.init_value = self.readInitValue(child_element)
-
-            parent.addProvidedComSpec(com_spec)
+        com_spec.uses_end_to_end_protection = self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION")
 
-    def readPPortPrototype(self, element, parent: AtomicSwComponentType):
-        for child_element in element.findall("./xmlns:PORTS/xmlns:P-PORT-PROTOTYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            self.logger.debug("readPPortPrototype %s" % short_name)
-
-            prototype = parent.createPPortPrototype(short_name)
-            self.readElementAttributes(child_element, prototype)
-            prototype.provided_interface_tref = self.readChildOptionalRefElement(child_element, "PROVIDED-INTERFACE-TREF")
-            self.readNonqueuedSenderComSpec(child_element, prototype)
+    def getNonqueuedSenderComSpec(self, element) -> NonqueuedSenderComSpec:
+        com_spec = NonqueuedSenderComSpec()
+        self.readSenderComSpec(element, com_spec)
+        com_spec.init_value = self.getInitValue(element)
+        return com_spec
+    
+    def getServerComSpec(self, element) -> ServerComSpec:
+        com_spec = ServerComSpec()
+        self.readSenderComSpec(element, com_spec)
+        com_spec.operation_ref = self.getChildElementOptionalRefType(element, "OPERATION-REF")
+        com_spec.queue_length = self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH")
+        return com_spec
+
+    def readProvidedComSpec(self, element: ET.Element, parent: PPortPrototype):
+        for child_element in element.findall("./xmlns:PROVIDED-COM-SPECS/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if tag_name == "NONQUEUED-SENDER-COM-SPEC":
+                parent.addProvidedComSpec(self.getNonqueuedSenderComSpec(child_element))
+            elif tag_name == "SERVER-COM-SPEC":
+                parent.addProvidedComSpec(self.getServerComSpec(child_element))
+            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.provided_interface_tref = self.getChildElementOptionalRefType(element, "PROVIDED-INTERFACE-TREF")
+
+        self.readProvidedComSpec(element, prototype)
+
+    def readPortGroupInnerGroupIRefs(self, element: ET.Element, parent: PortGroup):
+        for child_element in element.findall("./xmlns:INNER-GROUP-IREFS/xmlns:INNER-GROUP-IREF", self.nsmap):
+            inner_group_iref = InnerPortGroupInCompositionInstanceRef()
+            inner_group_iref.contextRef = self.getChildElementOptionalRefType(child_element, "CONTEXT-REF")
+            inner_group_iref.targetRef = self.getChildElementOptionalRefType(child_element, "TARGET-REF")
+            parent.addInnerGroupIRef(inner_group_iref)
+
+    def readPortGroupOuterPortRefs(self, element: ET.Element, parent: PortGroup):
+        for child_element in element.findall("./xmlns:OUTER-PORTS/xmlns:PORT-PROTOTYPE-REF-CONDITIONAL", self.nsmap):
+            parent.addOuterPortRef(self.getChildElementOptionalRefType(child_element, "PORT-PROTOTYPE-REF"))
+
+    def readPortGroup(self, element: ET.Element, parent: SwComponentType):
+        short_name = self.getShortName(element)
+        self.logger.debug("readPortGroup %s" % short_name)
+        port_group = parent.createPortGroup(short_name)
+        self.readIdentifiable(element, port_group)
+        self.readPortGroupInnerGroupIRefs(element, port_group)
+        self.readPortGroupOuterPortRefs(element, port_group)
+
+    def readSwComponentTypePortGroups(self, element: ET.Element, parent: SwComponentType):
+        for child_element in element.findall("./xmlns:PORT-GROUPS/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if tag_name == "PORT-GROUP":
+                self.readPortGroup(child_element, parent)
+            else:
+                self._raiseError("Unsupported Port Group type: %s" % tag_name)
 
-    def readSwComponentType(self, element, parent: SwComponentType):
-        self.readRPortPrototype(element, parent)
-        self.readPPortPrototype(element, parent)
+    def readSwComponentType(self, element: ET.Element, parent: SwComponentType):
+        self.readIdentifiable(element, parent)
+        self.readAtomicSwComponentTypePorts(element, parent)
+        self.readSwComponentTypePortGroups(element, parent)
 
     def readAtomicSwComponentType(self, element, parent: AtomicSwComponentType):
         self.readSwComponentType(element, parent)
-        self.readSwInternalBehavior(element, parent)
-
-    def readEcuAbstractionSwComponents(self, element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:ECU-ABSTRACTION-SW-COMPONENT-TYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            sw_component = parent.createEcuAbstractionSwComponentType(
-                short_name)
-            self.readAtomicSwComponentType(child_element, sw_component)
-
-    def readApplicationSwComponentTypes(self, element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:APPLICATION-SW-COMPONENT-TYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            sw_component = parent.createApplicationSwComponentType(short_name)
-            self.readAtomicSwComponentType(child_element, sw_component)
-
-    def readComplexDeviceDriverSwComponentTypes(self, element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:COMPLEX-DEVICE-DRIVER-SW-COMPONENT-TYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            sw_component = parent.createApplicationSwComponentType(short_name)
-            self.readAtomicSwComponentType(child_element, sw_component)
-
-    def readSensorActuatorSwComponentType(self, element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:SENSOR-ACTUATOR-SW-COMPONENT-TYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            sw_component = parent.createSensorActuatorSwComponentType(short_name)
-            self.readAtomicSwComponentType(child_element, sw_component)
-
-    def readServiceSwComponentTypes(self, element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:SERVICE-SW-COMPONENT-TYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            sw_component = parent.createServiceSwComponentType(short_name)
-            self.readAtomicSwComponentType(child_element, sw_component)
-
-    def readPPortInCompositionInstanceRef(self, element, p_port_in_composition_instance_ref: PPortInCompositionInstanceRef):
-        p_port_in_composition_instance_ref.context_component_ref = self.readChildOptionalRefElement(element, "CONTEXT-COMPONENT-REF")
-        p_port_in_composition_instance_ref.target_p_port_ref = self.readChildOptionalRefElement(element, "TARGET-P-PORT-REF")
+        self.readSwcInternalBehavior(element, parent)
+
+    def readEcuAbstractionSwComponent(self, element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        sw_component = parent.createEcuAbstractionSwComponentType(short_name)
+        self.readAtomicSwComponentType(element, sw_component)
+
+    def readApplicationSwComponentTypes(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        sw_component = parent.createApplicationSwComponentType(short_name)
+        self.readAtomicSwComponentType(element, sw_component)
+
+    def readComplexDeviceDriverSwComponentType(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        sw_component = parent.createComplexDeviceDriverSwComponentType(short_name)
+        self.logger.debug("readComplexDeviceDriverSwComponentType <%s>" % short_name)
+        self.readAtomicSwComponentType(element, sw_component)
+
+    def readSensorActuatorSwComponentType(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        sw_component = parent.createSensorActuatorSwComponentType(short_name)
+        self.logger.debug("readSensorActuatorSwComponentType <%s>" % short_name)
+        self.readAtomicSwComponentType(element, sw_component)
+
+    def readServiceSwComponentType(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        sw_component = parent.createServiceSwComponentType(short_name)
+        self.logger.debug("readServiceSwComponentType <%s>" % short_name)
+        self.readAtomicSwComponentType(element, sw_component)
+
+    def readPPortInCompositionInstanceRef(self, element: ET.Element, p_port_in_composition_instance_ref: PPortInCompositionInstanceRef):
+        p_port_in_composition_instance_ref.context_component_ref = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
+        p_port_in_composition_instance_ref.target_p_port_ref = self.getChildElementOptionalRefType(element, "TARGET-P-PORT-REF")
         
         self.logger.debug("PPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
@@ -985,8 +1240,8 @@ class ARXMLParser:
                           % (p_port_in_composition_instance_ref.target_p_port_ref.dest, p_port_in_composition_instance_ref.target_p_port_ref.value))
 
     def readRPortInCompositionInstanceRef(self, element, r_port_in_composition_instance_ref: RPortInCompositionInstanceRef):
-        r_port_in_composition_instance_ref.context_component_ref = self.readChildOptionalRefElement(element, "CONTEXT-COMPONENT-REF")
-        r_port_in_composition_instance_ref.target_r_port_ref = self.readChildOptionalRefElement(element, "TARGET-R-PORT-REF")
+        r_port_in_composition_instance_ref.context_component_ref = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
+        r_port_in_composition_instance_ref.target_r_port_ref = self.getChildElementOptionalRefType(element, "TARGET-R-PORT-REF")
 
         self.logger.debug("RPortInCompositionInstanceRef")
         self.logger.debug("  CONTEXT-COMPONENT-REF DEST: %s, %s"
@@ -994,44 +1249,44 @@ class ARXMLParser:
         self.logger.debug("  TARGET-P-PORT-REF DEST: %s, %s" 
                           % (r_port_in_composition_instance_ref.target_r_port_ref.dest, r_port_in_composition_instance_ref.target_r_port_ref.value))
 
-    def readAssemblySwConnectorProviderIRef(self, element, parent: AssemblySwConnector):
+    def readAssemblySwConnectorProviderIRef(self, element: ET.Element, parent: AssemblySwConnector):
         child_element = element.find("./xmlns:PROVIDER-IREF", self.nsmap)
-        if (child_element != None):
+        if (child_element is not None):
             provide_iref = PPortInCompositionInstanceRef()
             self.readElementAttributes(child_element, provide_iref)
             self.readPPortInCompositionInstanceRef(child_element, provide_iref)
             parent.provider_iref = provide_iref
 
-    def readAssemblySwConnectorRequesterIRef(self, element, parent: AssemblySwConnector):
+    def readAssemblySwConnectorRequesterIRef(self, element: ET.Element, parent: AssemblySwConnector):
         child_element = element.find("./xmlns:REQUESTER-IREF", self.nsmap)
-        if (child_element != None):
+        if (child_element is not None):
             requester_iref = RPortInCompositionInstanceRef()
             self.readElementAttributes(child_element, requester_iref)
             self.readRPortInCompositionInstanceRef(child_element, requester_iref)
             parent.requester_iref = requester_iref
 
-    def readAssemblySwConnectors(self, element, parent: CompositionSwComponentType):
+    def readAssemblySwConnectors(self, element: ET.Element, parent: CompositionSwComponentType):
         for child_element in element.findall("./xmlns:CONNECTORS/xmlns:ASSEMBLY-SW-CONNECTOR", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readAssemblySwConnectors %s" % short_name)
 
             connector = parent.createAssemblySwConnector(short_name)
-            self.readElementAttributes(child_element, connector)
+            self.readIdentifiable(child_element, connector)
             self.readAssemblySwConnectorProviderIRef(child_element, connector)
             self.readAssemblySwConnectorRequesterIRef(child_element, connector)
 
     def readDelegationSwConnectorInnerPortIRef(self, element, parent: DelegationSwConnector):
         inner_port_iref_element = element.find("./xmlns:INNER-PORT-IREF", self.nsmap)
-        if (inner_port_iref_element != None):
+        if (inner_port_iref_element is not None):
             child_element = inner_port_iref_element.find("./xmlns:R-PORT-IN-COMPOSITION-INSTANCE-REF", self.nsmap)
-            if (child_element != None):
+            if (child_element is not None):
                 r_port_in_composition_instance_ref = RPortInCompositionInstanceRef()
                 self.readRPortInCompositionInstanceRef(child_element, r_port_in_composition_instance_ref)
                 parent.inner_port_iref = r_port_in_composition_instance_ref
                 return
             
             child_element = inner_port_iref_element.find("./xmlns:P-PORT-IN-COMPOSITION-INSTANCE-REF", self.nsmap)
-            if (child_element != None):
+            if (child_element is not None):
                 p_port_in_composition_instance_ref = PPortInCompositionInstanceRef()
                 self.readPPortInCompositionInstanceRef(child_element, p_port_in_composition_instance_ref)
                 parent.inner_port_iref = p_port_in_composition_instance_ref
@@ -1041,111 +1296,131 @@ class ARXMLParser:
 
     def readDelegationSwConnectors(self, element, parent: CompositionSwComponentType):
         for child_element in element.findall("./xmlns:CONNECTORS/xmlns:DELEGATION-SW-CONNECTOR", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readDelegationSwConnectors %s" % short_name)
 
             connector = parent.createDelegationSwConnector(short_name)
-            self.readElementAttributes(child_element, connector)
+            self.readIdentifiable(child_element, connector)
             self.readDelegationSwConnectorInnerPortIRef(child_element, connector)
 
             if connector.inner_port_iref == None and connector.outer_port_iref == None:
                 self._raiseError("Invalid PortPrototype of DELEGATION-SW-CONNECTOR")
 
-            connector.outer_port_ref = self.readChildOptionalRefElement(child_element, "OUTER-PORT-REF")
+            connector.outer_port_ref = self.getChildElementOptionalRefType(child_element, "OUTER-PORT-REF")
             self.logger.debug("OUTER-PORT-REF DEST: %s, %s"
                           % (connector.outer_port_ref.dest, connector.outer_port_ref.value))
 
     def readSwComponentPrototypes(self, element: ET.Element, parent: CompositionSwComponentType):
         for child_element in element.findall("./xmlns:COMPONENTS/xmlns:SW-COMPONENT-PROTOTYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             self.logger.debug("readSwComponentPrototypes %s" % short_name)
-
             prototype = parent.createSwComponentPrototype(short_name)
-            self.readElementAttributes(child_element, prototype)
-            prototype.type_tref = self.readChildOptionalRefElement(child_element, "TYPE-TREF")
+            self.readIdentifiable(child_element, prototype)
+            prototype.type_tref = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
 
-    def readDataTypeMappingSet(self, element: ET.Element, parent: CompositionSwComponentType):
+    def readCompositionSwComponentTypeDataTypeMappingSet(self, element: ET.Element, parent: CompositionSwComponentType):
         child_element = element.find("./xmlns:DATA-TYPE-MAPPING-REFS", self.nsmap)
         self.logger.debug("readDataTypeMappingSet")
-        if child_element != None:
-            for ref in self.readChildRefElementList(child_element, "DATA-TYPE-MAPPING-REF"):
+        if child_element is not None:
+            for ref in self.getChildElementRefTypeList(child_element, "./DATA-TYPE-MAPPING-REF"):
                 parent.addDataTypeMapping(ref)
 
-    def readCompositionSwComponentTypes(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:COMPOSITION-SW-COMPONENT-TYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            self.logger.debug("readCompositionSwComponentTypes: <%s>" % short_name)
+    def readCompositionSwComponentType(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readCompositionSwComponentTypes: <%s>" % short_name)
 
-            sw_component = parent.createCompositionSwComponentType(short_name)
-            self.readIdentifiable(child_element, sw_component)
-            self.readSwComponentType(child_element, sw_component)
-            self.readSwComponentPrototypes(child_element, sw_component)
-            self.readAssemblySwConnectors(child_element, sw_component)
-            self.readDelegationSwConnectors(child_element, sw_component)
-            self.readDataTypeMappingSet(child_element, sw_component)
+        sw_component = parent.createCompositionSwComponentType(short_name)
+        self.readIdentifiable(element, sw_component)
+        self.readSwComponentType(element, sw_component)
+        self.readSwComponentPrototypes(element, sw_component)
+        self.readAssemblySwConnectors(element, sw_component)
+        self.readDelegationSwConnectors(element, sw_component)
+        self.readCompositionSwComponentTypeDataTypeMappingSet(element, sw_component)
 
-    def readDataTypeMap(self, element: ET.Element, parent: DataTypeMappingSet):
+        self.logger.debug("ReadCompositionSwComponentTypes: <%s> (Done)" % short_name)
+
+    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()
-            data_type_map.application_data_type_ref = self.readChildOptionalRefElement(child_element, "APPLICATION-DATA-TYPE-REF")
-            data_type_map.implementation_data_type_ref = self.readChildOptionalRefElement(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
+            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")
             parent.addDataTypeMap(data_type_map)
             # add the data type map to global namespace
             AUTOSAR.getInstance().addDataTypeMap(data_type_map)
 
-    def readDataTypeMappingSets(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:DATA-TYPE-MAPPING-SET", self.nsmap):
-            short_name = self.readShortName(child_element)
-            mapping_set = parent.createDataTypeMappingSet(short_name)
-            self.readDataTypeMap(child_element, mapping_set)
-
-    def readVariableDataPrototype(self, element: ET.Element, parent: SenderReceiverInterface):
+    def readModeRequestTypeMaps(self, element: ET.Element, parent: DataTypeMappingSet):
+        for child_element in element.findall("./xmlns:MODE-REQUEST-TYPE-MAPS/xmlns:MODE-REQUEST-TYPE-MAP", self.nsmap):
+            map = ModeRequestTypeMap()
+            self.readElementAttributes(child_element, map)
+            map.implementation_data_type_ref = self.getChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF")
+            map.mode_group_ref = self.getChildElementOptionalRefType(child_element, "MODE-GROUP-REF")
+            parent.addModeRequestTypeMap(map)
+
+    def readDataTypeMappingSet(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        mapping_set = parent.createDataTypeMappingSet(short_name)
+        self.readIdentifiable(element, mapping_set)
+        self.readDataTypeMaps(element, mapping_set)
+        self.readModeRequestTypeMaps(element, mapping_set)
+
+    def readDataElements(self, element: ET.Element, parent: SenderReceiverInterface):
         for child_element in element.findall("./xmlns:DATA-ELEMENTS/xmlns:VARIABLE-DATA-PROTOTYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             prototype = parent.createDataElement(short_name)
-            self.readSwDataDefProps(child_element, prototype)
-            prototype.type_tref = self.readChildOptionalRefElement(child_element, "TYPE-TREF")
+            self.readIdentifiable(child_element, prototype)
+            prototype.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
+            self.readAutosarDataPrototype(child_element, prototype)
+            prototype.init_value = self.getInitValue(child_element)
 
     def readSenderReceiverInterfaces(self, element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:SENDER-RECEIVER-INTERFACE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            sr_interface = parent.createSenderReceiverInterface(short_name)
-            self.readVariableDataPrototype(child_element, sr_interface)
+        short_name = self.getShortName(element)
+        sr_interface = parent.createSenderReceiverInterface(short_name)
+        self.readIdentifiable(element, sr_interface)
+        sr_interface.is_service = self.getChildElementOptionalBooleanValue(element, "IS-SERVICE")
+        self.readDataElements(element, sr_interface)
 
     def readArgumentDataPrototypes(self, element: ET.Element, parent: ClientServerOperation):
         for child_element in element.findall("./xmlns:ARGUMENTS/xmlns:ARGUMENT-DATA-PROTOTYPE", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             prototype = ArgumentDataPrototype(property, short_name)
-            prototype.type_tref = self.readChildOptionalRefElement(child_element, "TYPE-TREF")
-            prototype.direction = self.readChildElement(short_name, child_element, "DIRECTION")
+            self.readIdentifiable(child_element, prototype)
+            prototype.sw_data_def_props = self.getSwDataDefProps(child_element, "SW-DATA-DEF-PROPS")
+            prototype.type_tref = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
+            prototype.direction = self.getChildElementOptionalLiteral(child_element, "DIRECTION")
             parent.addArgumentDataPrototype(prototype)
 
     def readPossibleErrorRefs(self, element: ET.Element, parent: ClientServerOperation):
         child_element = element.find("./xmlns:POSSIBLE-ERROR-REFS", self.nsmap)
-        if child_element != None:
-            for ref in self.readChildRefElementList(child_element, "POSSIBLE-ERROR-REF"):
+        if child_element is not None:
+            for ref in self.getChildElementRefTypeList(child_element, "./POSSIBLE-ERROR-REF"):
                 parent.addPossibleErrorRef(ref)
 
     def readOperations(self, element: ET.Element, parent: ClientServerInterface):
         for child_element in element.findall("./xmlns:OPERATIONS/xmlns:CLIENT-SERVER-OPERATION", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             operation = parent.createOperation(short_name)
+            self.readIdentifiable(child_element, operation)
             self.readArgumentDataPrototypes(child_element, operation)
             self.readPossibleErrorRefs(child_element, operation)
 
     def readPossibleErrors(self, element: ET.Element, parent: ClientServerInterface):
         for child_element in element.findall("./xmlns:POSSIBLE-ERRORS/xmlns:APPLICATION-ERROR", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             error = parent.createApplicationError(short_name)
-            error.error_code = self.readChildElementNumberValue(short_name, child_element, "ERROR-CODE")
+            error.error_code = self.getChildElementOptionalNumericalValue(child_element, "ERROR-CODE")
+
+    def readPortInterface(self, element: ET.Element, port_interface: PortInterface):
+        port_interface.is_service = self.getChildElementOptionalBooleanValue(element, "IS-SERVICE")
+        port_interface.serviceKind = self.getChildElementOptionalLiteral(element, "SERVICE-KIND")
 
-    def readClientServerInterfaces(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:CLIENT-SERVER-INTERFACE", self.nsmap):
-            short_name = self.readShortName(child_element)
-            cs_interface = parent.createClientServerInterface(short_name)
-            cs_interface.is_service = self.readChildElement(short_name, child_element, "IS-SERVICE")
-            self.readOperations(child_element, cs_interface)
-            self.readPossibleErrors(child_element, cs_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)
@@ -1154,8 +1429,9 @@ class ARXMLParser:
             contents = CompuScaleConstantContents()
             contents.compu_const = CompuConst()
             contents.compu_const.compu_const_content_type = CompuConstTextContent()
-            contents.compu_const.compu_const_content_type.vt = child_element.text
-            parent.compu_scale_contents = contents
+            contents.compu_const.compu_const_content_type.vt = ARLiteral()
+            contents.compu_const.compu_const_content_type.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):
@@ -1172,7 +1448,7 @@ class ARXMLParser:
             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)
-            parent.compu_scale_contents = contents
+            parent.compuScaleContents = contents
 
     def readCompuScaleContents(self, element: ET.Element, parent: CompuScale):
         self.readCompuConst(element, parent)
@@ -1181,165 +1457,615 @@ class ARXMLParser:
     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()
-            compu_scale.lower_limit = self.readChildLimitElement(child_element, "LOWER-LIMIT")
-            compu_scale.upper_limit = self.readChildLimitElement(child_element, "UPPER-LIMIT")
+            self.readElementAttributes(child_element, compu_scale)
+            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)
-        if (child_element != None):
+        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)
 
-    def readCompuMethods(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:COMPU-METHOD", self.nsmap):
-            short_name = self.readShortName(child_element)
-            self.logger.debug("readCompuMethods %s" % short_name)
-            compu_method = parent.createCompuMethod(short_name)
-            self.readIdentifiable(child_element, compu_method)
-            compu_method.unit_ref = self.readChildOptionalRefElement(child_element, "UNIT-REF")
-            self.readCompuInternalToPhys(child_element, compu_method)
+    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")
+        self.readCompuInternalToPhys(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):
             mapping = SwcBswRunnableMapping()
-            mapping.bsw_entity_ref = self.readChildOptionalRefElement(child_element, "BSW-ENTITY-REF")
-            mapping.swc_runnable_ref = self.readChildOptionalRefElement(child_element, "SWC-RUNNABLE-REF")
+            mapping.bswEntityRef = self.getChildElementOptionalRefType(child_element, "BSW-ENTITY-REF")
+            mapping.swcRunnableRef = self.getChildElementOptionalRefType(child_element, "SWC-RUNNABLE-REF")
             parent.addRunnableMapping(mapping)
 
     def readSwcBswMappings(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:SWC-BSW-MAPPING", self.nsmap):
-            short_name = self.readShortName(child_element)
-            self.logger.debug("readSwcBswMappings %s" % short_name)
-            swc_bsw_mapping = parent.createSwcBswMapping(short_name)
-            swc_bsw_mapping.bsw_behavior_ref = self.readChildOptionalRefElement(child_element, "BSW-BEHAVIOR-REF")
-            self.readSwcBswRunnableMappings(child_element, swc_bsw_mapping)
-            swc_bsw_mapping.swc_behavior_ref = self.readChildOptionalRefElement(child_element, "SWC-BEHAVIOR-REF")
+        short_name = self.getShortName(element)
+        self.logger.debug("readSwcBswMappings %s" % short_name)
+        swc_bsw_mapping = parent.createSwcBswMapping(short_name)
+        swc_bsw_mapping.bswBehaviorRef = self.getChildElementOptionalRefType(element, "BSW-BEHAVIOR-REF")
+        self.readSwcBswRunnableMappings(element, swc_bsw_mapping)
+        swc_bsw_mapping.swcBehaviorRef = self.getChildElementOptionalRefType(element, "SWC-BEHAVIOR-REF")
 
     def readValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
-        value_spec.short_label = self.readChildOptionalElement(element, "SHORT-LABEL")
-
-    def readSwValueCont(self, element: ET.Element, spec: ApplicationValueSpecification):
-        child_element = element.find("./xmlns:SW-VALUE-CONT", self.nsmap)
-        if child_element is not None:
-            sw_value_cont = SwValueCont()
-            sw_value_cont.unit_ref = self.readChildOptionalRefElement(child_element, "UNIT-REF")
-            sw_value_cont.sw_values_phys = self.readSwValues(child_element, "SW-VALUES-PHYS")
-            spec.sw_value_cont = sw_value_cont
+        self.readElementAttributes(element, value_spec)
+        value_spec.short_label = self.getChildElementOptionalLiteral(element, "SHORT-LABEL")
+        self.logger.debug("readValueSpecification")
 
-    def readApplicationValueSpecification(self, element: ET.Element) -> ApplicationValueSpecification:
+    def getApplicationValueSpecification(self, element: ET.Element) -> ApplicationValueSpecification:
+        self.logger.debug("getApplicationValueSpecification")
         value_spec = ApplicationValueSpecification()
         self.readValueSpecification(element, value_spec)
-        value_spec.category = self.readChildOptionalElement(element, "CATEGORY")
-        self.readSwValueCont(element, value_spec)
+        value_spec.category = self.getChildElementOptionalLiteral(element, "CATEGORY")
+        value_spec.sw_value_cont = 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")
+        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")
+        return value_spec
+
+    def getArrayValueSpecification(self, element: ET.Element) -> ArrayValueSpecification:
+        self.logger.debug("getArrayValueSpecification")
+        value_spec = ArrayValueSpecification()
+        self.readValueSpecification(element, value_spec)
+        child_elements = element.findall("./xmlns:ELEMENTS/*", self.nsmap)
+        for child_element in child_elements:
+            value_spec.add_element(self.getValueSpecification(child_element))
+        return value_spec
+
+    def getConstantReference(self, element: ET.Element) -> ConstantReference:
+        self.logger.debug("getConstantReference")
+        value_spec = ConstantReference()
+        self.readValueSpecification(element, value_spec)
+        value_spec.constant_ref = self.getChildElementOptionalRefType(element, "CONSTANT-REF")
+        return value_spec         
+
+    def getValueSpecification(self, element: ET.Element) -> ValueSpecification:
+        tag_name = self.getTagName(element.tag)
+        if tag_name == "APPLICATION-VALUE-SPECIFICATION":
+            value_spec = self.getApplicationValueSpecification(element)
+        elif tag_name == "RECORD-VALUE-SPECIFICATION":
+            value_spec = self.getRecordValueSpecification(element)
+        elif tag_name == "NUMERICAL-VALUE-SPECIFICATION":
+            value_spec = self.getNumericalValueSpecification(element)
+        elif tag_name == "ARRAY-VALUE-SPECIFICATION":
+            value_spec = self.getArrayValueSpecification(element)
+        elif tag_name == "TEXT-VALUE-SPECIFICATION":
+            value_spec = self.getTextValueSpecification(element)
+        elif tag_name == "CONSTANT-REFERENCE":
+            value_spec = self.getConstantReference(element)
+        else:
+            raise NotImplementedError("Unsupported RecordValueSpecificationField %s" % tag_name)
         return value_spec
 
     def readRecordValueSpecificationFields(self, element: ET.Element, spec: RecordValueSpecification):
         for child_element in element.findall("./xmlns:FIELDS/*", self.nsmap):
-            if child_element.tag == "{http://autosar.org/schema/r4.0}APPLICATION-VALUE-SPECIFICATION":
-                value_spec = self.readApplicationValueSpecification(child_element)
-            elif child_element.tag == "{http://autosar.org/schema/r4.0}RECORD-VALUE-SPECIFICATION":
-                value_spec = self.readRecordValueSpecification(child_element)
-            else:
-                raise NotImplementedError("Unsupported VALUE-SPEC %s" % child_element.tag)
-            spec.add_field(value_spec)
+            spec.add_field(self.getValueSpecification(child_element))
 
-    def readRecordValueSpecification(self, element: ET.Element) -> RecordValueSpecification:
+    def getRecordValueSpecification(self, element: ET.Element) -> RecordValueSpecification:
         value_spec = RecordValueSpecification()
         self.readValueSpecification(element, value_spec)
         self.readRecordValueSpecificationFields(element, value_spec)
         return value_spec
 
     def readConstantSpecification(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:CONSTANT-SPECIFICATION", self.nsmap):
-            short_name = self.readShortName(child_element)
-            self.logger.debug("readConstantSpecification %s" % short_name)
-            spec = parent.createConstantSpecification(short_name)
-            self.readIdentifiable(child_element, spec)
-            for value_spec_tag in child_element.findall("./xmlns:VALUE-SPEC/*", self.nsmap):
-                if value_spec_tag.tag == "{http://autosar.org/schema/r4.0}APPLICATION-VALUE-SPECIFICATION":
-                    spec.value_spec = self.readApplicationValueSpecification(value_spec_tag)
-                elif value_spec_tag.tag == "{http://autosar.org/schema/r4.0}RECORD-VALUE-SPECIFICATION":
-                    spec.value_spec = self.readRecordValueSpecification(value_spec_tag)
-                else:
-                    raise NotImplementedError("Unsupported VALUE-SPEC %s" % value_spec_tag.tag)
+        short_name = self.getShortName(element)
+        self.logger.debug("readConstantSpecification %s" % short_name)
+        spec = parent.createConstantSpecification(short_name)
+        self.readIdentifiable(element, spec)
+        for value_spec_tag in element.findall("./xmlns:VALUE-SPEC/*", self.nsmap):
+            spec.value_spec = self.getValueSpecification(value_spec_tag)
                 
     def readInternalConstrs(self, element: ET.Element, parent: DataConstrRule):
         child_element = element.find("./xmlns:INTERNAL-CONSTRS", self.nsmap)
         if child_element is not None:
             constrs = InternalConstrs()
-            constrs.lower_limit = self.readChildLimitElement(child_element, "LOWER-LIMIT")
-            constrs.upper_limit = self.readChildLimitElement(child_element, "UPPER-LIMIT")
-            parent.internal_constrs = constrs
+            self.readElementAttributes(child_element, constrs)
+            constrs.lower_limit = self.getChildLimitElement(child_element, "LOWER-LIMIT")
+            constrs.upper_limit = self.getChildLimitElement(child_element, "UPPER-LIMIT")
+            parent.internalConstrs = constrs
 
     def readPhysConstrs(self, element: ET.Element, parent: DataConstrRule):
         child_element = element.find("./xmlns:PHYS-CONSTRS", self.nsmap)
         if child_element is not None:
             constrs = PhysConstrs()
-            constrs.lower_limit = self.readChildLimitElement(child_element, "LOWER-LIMIT")
-            constrs.upper_limit = self.readChildLimitElement(child_element, "UPPER-LIMIT")
-            constrs.unit_ref = self.readChildOptionalRefElement(child_element, "UNIT-REF")
-            parent.phys_constrs = constrs
+            self.readElementAttributes(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")
+            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")
             rule = DataConstrRule()
+            self.readElementAttributes(child_element, rule)
+            rule.constrLevel = self.getChildElementOptionalNumericalValue(child_element, "CONSTR-LEVEL")
             self.readInternalConstrs(child_element, rule)
             self.readPhysConstrs(child_element, rule)
             parent.addDataConstrRule(rule)
                 
     def readDataConstr(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:DATA-CONSTR", self.nsmap):
-            short_name = self.readShortName(child_element)
-            self.logger.debug("readDataConstr %s" % short_name)
-            constr = parent.createDataConstr(short_name)
-            self.readIdentifiable(child_element, constr)
-            self.readDataConstrRule(child_element, constr)
+        short_name = self.getShortName(element)
+        self.logger.debug("readDataConstr %s" % short_name)
+        constr = parent.createDataConstr(short_name)
+        self.readIdentifiable(element, constr)
+        self.readDataConstrRule(element, constr)
 
     def readUnit(self, element: ET.Element, parent: ARPackage):
-        for child_element in element.findall("./xmlns:ELEMENTS/xmlns:UNIT", self.nsmap):
-            short_name = self.readShortName(child_element)
-            self.logger.debug("readUnit %s" % short_name)
-            unit = parent.createUnit(short_name)
-            self.readIdentifiable(child_element, unit)
-            unit.display_name = self.readChildOptionalElementLiteral(child_element, "DISPLAY-NAME")
+        short_name = self.getShortName(element)
+        self.logger.debug("readUnit %s" % short_name)
+        unit = parent.createUnit(short_name)
+        self.readIdentifiable(element, unit)
+        unit.display_name = self.getChildElementOptionalLiteral(element, "DISPLAY-NAME")
+
+    def readEndToEndDescriptionDataId(self, element: ET.Element, parent: EndToEndDescription):
+        child_element = element.find("./xmlns:DATA-IDS", self.nsmap)
+        if child_element is not None:
+            for value in self.getChildElementNumericalValueList(child_element, "DATA-ID"):
+                parent.addDataId(value)
+
+    def getEndToEndDescription(self, element: ET.Element, key: str) -> EndToEndDescription:
+        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        desc = None
+        if (child_element is not None):
+            desc = EndToEndDescription()
+            desc.category = self.getChildElementOptionalLiteral(child_element, "CATEGORY")
+            self.readEndToEndDescriptionDataId(child_element, desc)
+            desc.dataIdMode = self.getChildElementOptionalNumericalValue(child_element, "DATA-ID-MODE")
+            desc.maxDeltaCounterInit = self.getChildElementOptionalNumericalValue(child_element, "MAX-DELTA-COUNTER-INIT")
+            desc.crcOffset = self.getChildElementOptionalNumericalValue(child_element, "CRC-OFFSET")
+            desc.counterOffset = self.getChildElementOptionalNumericalValue(child_element, "COUNTER-OFFSET")
+        return desc
+    
+    def getVariableDataPrototypeInSystemInstanceRef(self, element: ET.Element) -> VariableDataPrototypeInSystemInstanceRef:
+        iref = VariableDataPrototypeInSystemInstanceRef()
+        iref.context_component_refs = self.getChildElementOptionalRefType(element, "CONTEXT-COMPONENT-REF")
+        iref.context_composition_ref = self.getChildElementOptionalRefType(element, "CONTEXT-COMPOSITION-REF")
+        iref.context_port_ref = self.getChildElementOptionalRefType(element, "CONTEXT-PORT-REF")
+        iref.target_data_prototype_ref = self.getChildElementOptionalRefType(element, "TARGET-DATA-PROTOTYPE-REF")
+        return iref
+    
+    def getEndToEndProtectionVariablePrototype(self, element: ET.Element) -> EndToEndProtectionVariablePrototype:
+        prototype = EndToEndProtectionVariablePrototype()
+        for child_element in element.findall("./xmlns:RECEIVER-IREFS/xmlns:RECEIVER-IREF", self.nsmap):
+            prototype.addReceiverIref(self.getVariableDataPrototypeInSystemInstanceRef(child_element))
+        child_element = element.find("./xmlns:SENDER-IREF", self.nsmap)
+        if child_element is not None:
+            prototype.senderIRef = self.getVariableDataPrototypeInSystemInstanceRef(child_element)
+        return prototype
+    
+    def readEndToEndProtectionVariablePrototypes(self, element: ET.Element, parent: EndToEndProtection):
+        for child_element in element.findall("./xmlns:END-TO-END-PROTECTION-VARIABLE-PROTOTYPES/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if tag_name == "END-TO-END-PROTECTION-VARIABLE-PROTOTYPE":
+                parent.addEndToEndProtectionVariablePrototype(self.getEndToEndProtectionVariablePrototype(child_element))
+            else:
+                self._raiseError("Unsupported End To End Protection Variable Prototype <%s>" % tag_name)
+
+    def readEndToEndProtection(self, element: ET.Element, parent: EndToEndProtectionSet):
+        short_name = self.getShortName(element)
+        self.logger.debug("readEndToEndProtection %s" % short_name)
+        protection = parent.createEndToEndProtection(short_name)
+        self.readIdentifiable(element, protection)
+        protection.endToEndProfile = self.getEndToEndDescription(element, "END-TO-END-PROFILE")
+        self.readEndToEndProtectionVariablePrototypes(element, protection)
+
+    def readEndToEndProtections(self, element: ET.Element, parent: EndToEndProtectionSet):
+        for child_element in element.findall("./xmlns:END-TO-END-PROTECTIONS/*", self.nsmap):
+            tag_name = self.getTagName(child_element.tag)
+            if tag_name == "END-TO-END-PROTECTION":
+                self.readEndToEndProtection(child_element, parent)
+
+    def readEndToEndProtectionSet(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readEndToEndProtectionSet %s" % short_name)
+        protection_set = parent.createEndToEndProtectionSet(short_name)
+        self.readEndToEndProtections(element, protection_set)
+
+    def readAutosarDataType(self, element: ET.Element, data_type: AutosarDataType):
+        self.readIdentifiable(element, data_type)
+        data_type.sw_data_def_props = self.getSwDataDefProps(element, "SW-DATA-DEF-PROPS")
+
+    def readApplicationDataType(self, element: ET.Element, data_type: ApplicationDataType):
+        self.readAutosarDataType(element, data_type)
+
+    def readApplicationCompositeDataType(self, element: ET.Element, data_type: ApplicationCompositeDataType):
+        self.readApplicationDataType(element, data_type)
+
+    def readDataPrototype(self, element: ET.Element, prototype: DataPrototype):
+        self.readIdentifiable(element, prototype)
+
+    def readApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
+        self.readDataPrototype(element, prototype)
+        prototype.typeTRef = self.getChildElementOptionalRefType(element, "TYPE-TREF")
+
+    def readApplicationArrayElement(self, element: ET.Element, parent: ApplicationArrayDataType):
+        child_element = element.find("./xmlns:ELEMENT", self.nsmap)
+        if child_element is not None:
+            short_name = self.getShortName(child_element)
+            self.logger.debug("readApplicationArrayElement %s" % short_name)
+            array_element = parent.createApplicationArrayElement(short_name)
+            self.readApplicationCompositeElementDataPrototype(child_element, array_element)
+            array_element.setArraySizeSemantics(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS"))
+            array_element.setMaxNumberOfElements(self.getChildElementOptionalNumericalValue(child_element, "MAX-NUMBER-OF-ELEMENTS"))
+
+    def readApplicationArrayDataType(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readApplicationArrayDataType %s" % short_name)
+        data_type = parent.createApplicationArrayDataType(short_name)
+        self.readApplicationCompositeDataType(element, data_type)
+        self.readApplicationArrayElement(element, data_type)
+
+    def getSwRecordLayoutV(self, element: ET.Element, key: str) -> SwRecordLayoutV:
+        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        layout_v = None
+        if child_element is not None:
+            layout_v = SwRecordLayoutV()
+            layout_v.setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
+                    .setBaseTypeRef(self.getChildElementOptionalRefType(child_element, "BASE-TYPE-REF")) \
+                    .setSwRecordLayoutVAxis(self.getChildElementOptionalNumericalValue(child_element, "SW-RECORD-LAYOUT-V-AXIS")) \
+                    .setSwRecordLayoutVProp(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-PROP")) \
+                    .setSwRecordLayoutVIndex(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-INDEX"))
+        return layout_v
+
+    def getSwRecordLayoutGroup(self, element: ET.Element, key: str) -> SwRecordLayoutGroup:
+        child_element = element.find("./xmlns:%s" % key, self.nsmap)
+        group = None
+        if child_element is not None:
+            group = SwRecordLayoutGroup()
+            group.setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
+                 .setCategory(self.getChildElementOptionalLiteral(child_element, "CATEGORY")) \
+                 .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")) \
+                 .setSwRecordLayoutGroupTo(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO")) \
+            
+            group_content = SwRecordLayoutGroupContent()
+            group_content.swRecordLayoutGroup = self.getSwRecordLayoutGroup(child_element, "SW-RECORD-LAYOUT-GROUP")
+            group_content.swRecordLayoutV = self.getSwRecordLayoutV(child_element, "SW-RECORD-LAYOUT-V")
+
+            if group_content.swRecordLayoutGroup is not None:
+                group.setSwRecordLayoutGroupContentType(group_content)
+            elif group_content.swRecordLayoutV is not None:
+                group.setSwRecordLayoutGroupContentType(group_content)
+
+        return group
+
+    def readSwRecordLayout(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readSwRecordLayout %s" % short_name)
+        layout = parent.createSwRecordLayout(short_name)
+        self.readIdentifiable(element, layout)
+        layout.setSwRecordLayoutGroup(self.getSwRecordLayoutGroup(element, "SW-RECORD-LAYOUT-GROUP"))
+
+    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)
+
+    def readTriggerInterface(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readTriggerInterface %s" % short_name)
+        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):
+            short_name = self.getShortName(child_element)
+            declaration = parent.createModeDeclaration(short_name)
+            declaration.setValue(self.getChildElementOptionalNumericalValue(child_element, "VALUE"))
+
+    def readModeDeclarationGroup(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readModeDeclarationGroup %s" % short_name)
+        group = parent.createModeDeclarationGroup(short_name)
+        self.readIdentifiable(element, group)
+        self.readModeDeclarationGroupModeDeclaration(element, group)
+        group.setInitialModeRef(self.getChildElementOptionalRefType(element, "INITIAL-MODE-REF"))
+        group.setOnTransitionValue(self.getChildElementOptionalNumericalValue(element, "ON-TRANSITION-VALUE"))
+
+    def readModeSwitchInterfaceModeGroup(self, element: ET.Element, parent: ModeSwitchInterface):
+        child_element = self.find(element, "MODE-GROUP")
+        if child_element is not None:
+            short_name = self.getShortName(child_element)
+            mode_group = parent.createModeGroup(short_name)
+            self.readIdentifiable(child_element, mode_group)
+            mode_group.type_tref = self.getChildElementOptionalRefType(child_element, "TYPE-TREF")
+
+    def readModeSwitchInterface(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readModeSwitchInterface %s" % short_name)
+        mode_interface = parent.createModeSwitchInterface(short_name)
+        self.readPortInterface(element, mode_interface)
+        self.readModeSwitchInterfaceModeGroup(element, mode_interface)
+
+    def readEOCExecutableEntityRef(self, element: ET.Element, constraint: ExecutionOrderConstraint):
+        short_name = self.getShortName(element)
+        self.logger.debug("readEocExecutableEntityRef %s" % short_name)
+        entity_ref = constraint.createEOCExecutableEntityRef(short_name)
+        self.readIdentifiable(element, entity_ref)
+        for ref in self.getChildElementRefTypeList(element, "SUCCESSOR-REFS/SUCCESSOR-REF"):
+            entity_ref.addSuccessorRef(ref)
+
+    def readExecutionOrderConstraintOrderedElement(self, element: ET.Element, constrain: ExecutionOrderConstraint):
+        for child_element in self.findall(element, "ORDERED-ELEMENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "EOC-EXECUTABLE-ENTITY-REF":
+                self.readEOCExecutableEntityRef(child_element, constrain)
+            else:
+                self._raiseError("Unsupported order element <%s>." % tag_name)
+
+    def readExecutionOrderConstraint(self, element: ET.Element, extension: TimingExtension):
+        short_name = self.getShortName(element)
+        self.logger.debug("readExecutionOrderConstraint %s" % short_name)
+        constraint = extension.createExecutionOrderConstraint(short_name)
+        self.readIdentifiable(element, constraint)
+        self.readExecutionOrderConstraintOrderedElement(element, constraint)
+
+    def readTimingExtension(self, element: ET.Element, extension: TimingExtension):
+        for child_element in self.findall(element, "TIMING-REQUIREMENTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "EXECUTION-ORDER-CONSTRAINT":
+                self.readExecutionOrderConstraint(child_element, extension)
+            else:
+                self._raiseError("Unsupported timing requirement <%s>" % tag_name)
+
+    def readSwcTiming(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readSwcTiming %s" % short_name)
+        timing = parent.createSwcTiming(short_name)
+        self.readIdentifiable(element, timing)
+        self.readTimingExtension(element, timing)
+
+    def readLinCluster(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readLinCluster %s" % short_name)
+        cluster = parent.createLinCluster(short_name)
+        self.readIdentifiable(element, cluster)
+
+    def readPduToFrameMappings(self, element: ET.Element, parent: Frame):
+        for child_element in self.findall(element, "PDU-TO-FRAME-MAPPINGS/PDU-TO-FRAME-MAPPING"):
+            short_name = self.getShortName(child_element)
+            self.logger.debug("readPduToFrameMapping %s" % short_name)
+            mapping = parent.createPduToFrameMapping(short_name)
+            self.readIdentifiable(child_element, mapping)
+            mapping.packingByteOrder = self.getChildElementOptionalLiteral(child_element, "PACKING-BYTE-ORDER")
+            mapping.pduRef = self.getChildElementOptionalRefType(child_element, "PDU-REF")
+            mapping.startPosition = self.getChildElementOptionalNumericalValue(child_element, "START-POSITION")
+
+    def readFrame(self, element: ET.Element, frame: Frame):
+        self.readIdentifiable(element, frame)
+        frame.frameLength = self.getChildElementOptionalNumericalValue(element, "FRAME-LENGTH")
+        self.readPduToFrameMappings(element, frame)
+
+    def readLinUnconditionalFrame(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("LinUnconditionalFrame %s" % short_name)
+        frame = parent.createLinUnconditionalFrame(short_name)
+        self.readFrame(element, frame)
+
+    def readNmPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readNmPdu %s" % short_name)
+        pdu = parent.createNmPdu(short_name)
+        self.readIdentifiable(element, pdu)
+
+    def readNPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readNPdu %s" % short_name)
+        pdu = parent.createNPdu(short_name)
+        self.readIdentifiable(element, pdu)
+
+    def readDcmIPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("readDcmIPdu %s" % short_name)
+        pdu = parent.createDcmIPdu(short_name)
+        self.readIdentifiable(element, pdu)
+
+    def readNmConfig(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("NmConfig %s" % short_name)
+        pdu = parent.createNmConfig(short_name)
+        self.readIdentifiable(element, pdu)
+
+    def readCanTpConfig(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("CanTpConfig %s" % short_name)
+        pdu = parent.createCanTpConfig(short_name)
+        self.readIdentifiable(element, pdu)
+
+    def readCanFrame(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("CanFrame %s" % short_name)
+        frame = parent.createCanFrame(short_name)
+        self.readFrame(element, frame)
+
+    '''
+    def getFrameMappings(self, element: ET.Element) -> List[FrameMapping]:
+        mappings = []
+        for child_element in self.findall(element, 'FRAME-MAPPINGS/'):
+            mapping = FrameMapping()
+            mapping.sourceFrameRef = self.getChildElementOptionalRefType(child_element, "SOURCE-FRAME-REF")
+            mapping.targetFrameRef = self.getChildElementOptionalRefType(child_element, "TARGET-FRAME-REF")
+            mappings.append(mapping)
+        return mappings
+    '''
+
+    def getISignalMappings(self, element: ET.Element) -> List[ISignalMapping]:
+        mappings = []
+        for child_element in self.findall(element, "SIGNAL-MAPPINGS/I-SIGNAL-MAPPING"):
+            mapping = ISignalMapping()
+            mapping.sourceSignalRef = self.getChildElementOptionalRefType(child_element, "SOURCE-SIGNAL-REF")
+            mapping.targetSignalRef = self.getChildElementOptionalRefType(child_element, "TARGET-SIGNAL-REF")
+            mappings.append(mapping)
+        return mappings
+    
+    '''
+    def getIPduMappings(self, element: ET.Element) -> List[IPduMapping]:
+        mappings = []
+        for child_element in self.findall(element, tag_name):
+            mapping = IPduMapping()
+            mapping.sourceIPduRef = self.getChildElementOptionalRefType(child_element, "SOURCE-IPDU-REF")
+            mapping.targetIPduRef = self.getChildElementOptionalRefType(child_element, "TARGET-IPDU-REF")
+            mappings.append(mapping)
+        return mappings
+    '''
+
+    def readGateway(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Gateway %s" % short_name)
+        gateway = parent.createGateway(short_name)
+        self.readIdentifiable(element, gateway)
+        gateway.ecuRef = self.getChildElementOptionalRefType(element, "ECU-REF")
+        for mapping in self.getISignalMappings(element):
+            gateway.addSignalMapping(mapping)
+
+    def readISignal(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("ISignal %s" % short_name)
+        signal = parent.createISignal(short_name)
+        self.readIdentifiable(element, signal)
+        signal.dataTypePolicy = self.getChildElementOptionalLiteral(element, "DATA-TYPE-POLICY")
+        signal.initValue = self.getInitValue(element)
+        signal.length = self.getChildElementOptionalNumericalValue(element, "LENGTH")
+        signal.networkRepresentationProps = self.getSwDataDefProps(element, "NETWORK-REPRESENTATION-PROPS")
+        signal.systemSignalRef = self.getChildElementOptionalRefType(element, "SYSTEM-SIGNAL-REF")
+
+    def readARPackageElements(self, element: ET.Element, parent: ARPackage):
+        for child_element in self.findall(element, "./ELEMENTS/*"):
+            tag_name = self.getTagName(child_element.tag)
+            if tag_name == "COMPOSITION-SW-COMPONENT-TYPE":
+                self.readCompositionSwComponentType(child_element, parent)
+            elif tag_name == "COMPLEX-DEVICE-DRIVER-SW-COMPONENT-TYPE":
+                self.readComplexDeviceDriverSwComponentType(child_element, parent)
+            elif tag_name == "SWC-IMPLEMENTATION":
+                self.readSwcImplementation(child_element, parent)
+            elif tag_name == "APPLICATION-PRIMITIVE-DATA-TYPE":
+                self.readApplicationPrimitiveDataType(child_element, parent)
+            elif tag_name == "APPLICATION-RECORD-DATA-TYPE":
+                self.readApplicationRecordDataTypes(child_element, parent)
+            elif tag_name == "SW-BASE-TYPE":
+                self.readSwBaseType(child_element, parent)
+            elif tag_name == "COMPU-METHOD":
+                self.readCompuMethod(child_element, parent)
+            elif tag_name == "CONSTANT-SPECIFICATION":
+                self.readConstantSpecification(child_element, parent)
+            elif tag_name == "DATA-CONSTR":
+                self.readDataConstr(child_element, parent)
+            elif tag_name == "END-TO-END-PROTECTION-SET":
+                self.readEndToEndProtectionSet(child_element, parent)
+            elif tag_name == "SENDER-RECEIVER-INTERFACE":
+                self.readSenderReceiverInterfaces(child_element, parent)
+            elif tag_name == "UNIT":
+                self.readUnit(child_element, parent)
+            elif tag_name == "BSW-MODULE-DESCRIPTION":
+                self.readBswModuleDescription(child_element, parent)
+            elif tag_name == "BSW-MODULE-ENTRY":
+                self.readBswModuleEntry(child_element, parent)
+            elif tag_name == "SWC-BSW-MAPPING":
+                self.readSwcBswMappings(child_element, parent)
+            elif tag_name == "BSW-IMPLEMENTATION":
+                self.readBswImplementation(child_element, parent)
+            elif tag_name == "IMPLEMENTATION-DATA-TYPE":
+                self.readImplementationDataType(child_element, parent)
+            elif tag_name == "CLIENT-SERVER-INTERFACE":
+                self.readClientServerInterface(child_element, parent)
+            elif tag_name == "APPLICATION-SW-COMPONENT-TYPE":
+                self.readApplicationSwComponentTypes(child_element, parent)
+            elif tag_name == "ECU-ABSTRACTION-SW-COMPONENT-TYPE":
+                self.readEcuAbstractionSwComponent(child_element, parent)
+            elif tag_name == "APPLICATION-ARRAY-DATA-TYPE":
+                self.readApplicationArrayDataType(child_element, parent)
+            elif tag_name == "SW-RECORD-LAYOUT":
+                self.readSwRecordLayout(child_element, parent)
+            elif tag_name == "SW-ADDR-METHOD":
+                self.readSwAddrMethod(child_element, parent)
+            elif tag_name == "TRIGGER-INTERFACE":
+                self.readTriggerInterface(child_element, parent)
+            elif tag_name == "SERVICE-SW-COMPONENT-TYPE":
+                self.readServiceSwComponentType(child_element, parent)
+            elif tag_name == "SENSOR-ACTUATOR-SW-COMPONENT-TYPE":
+                self.readSensorActuatorSwComponentType(child_element, parent)
+            elif tag_name == "DATA-TYPE-MAPPING-SET":
+                self.readDataTypeMappingSet(child_element, parent)
+            elif tag_name == "MODE-DECLARATION-GROUP":
+                self.readModeDeclarationGroup(child_element, parent)
+            elif tag_name == "MODE-SWITCH-INTERFACE":
+                self.readModeSwitchInterface(child_element, parent)
+            elif tag_name == "SWC-TIMING":
+                self.readSwcTiming(child_element, parent)
+            elif tag_name == "LIN-CLUSTER":
+                self.readLinCluster(child_element, parent)
+            elif tag_name == "LIN-UNCONDITIONAL-FRAME":
+                self.readLinUnconditionalFrame(child_element, parent)
+            elif tag_name == "NM-PDU":
+                self.readNmPdu(child_element, parent)
+            elif tag_name == "N-PDU":
+                self.readNPdu(child_element, parent)
+            elif tag_name == "DCM-I-PDU":
+                self.readDcmIPdu(child_element, parent)
+            elif tag_name == "NM-CONFIG":
+                self.readNmConfig(child_element, parent)
+            elif tag_name == "CAN-TP-CONFIG":
+                self.readCanTpConfig(child_element, parent)
+            elif tag_name == "SYSTEM":
+                pass
+            elif tag_name == "ECU-INSTANCE":
+                pass
+            elif tag_name == "GATEWAY":
+                self.readGateway(child_element, parent)
+            elif tag_name == "I-SIGNAL-I-PDU-GROUP":
+                pass
+            elif tag_name == "CAN-CLUSTER":
+                pass
+            elif tag_name == "CAN-FRAME":
+                self.readCanFrame(child_element, parent)
+            elif tag_name == "I-SIGNAL":
+                self.readISignal(child_element, parent)
+                pass
+            elif tag_name == "I-SIGNAL-GROUP":
+                pass
+            elif tag_name == "I-SIGNAL-I-PDU":
+                pass
+            elif tag_name == "SYSTEM-SIGNAL":
+                pass
+            elif tag_name == "SYSTEM-SIGNAL-GROUP":
+                pass
+            else:
+                self._raiseError("Unsupported element type of ARPackage <%s>" % tag_name)
+                #pass
+
+    
 
     def readARPackages(self, element: ET.Element, parent: ARPackage):
         for child_element in element.findall("./xmlns:AR-PACKAGES/xmlns:AR-PACKAGE", self.nsmap):
-            short_name = self.readShortName(child_element)
+            short_name = self.getShortName(child_element)
             ar_package = parent.createARPackage(short_name)
 
             self.logger.debug("readARPackages %s" % ar_package.full_name)
 
-            self.readElementAttributes(child_element, ar_package)
-
-            self.readSenderReceiverInterfaces(child_element, ar_package)
-            self.readClientServerInterfaces(child_element, ar_package)
-            self.readDataTypeMappingSets(child_element, ar_package)
+            self.readIdentifiable(child_element, ar_package)
+            self.readARPackageElements(child_element, ar_package)
             self.readARPackages(child_element, ar_package)
-            self.readApplicationPrimitiveDataTypes(child_element, ar_package)
-            self.readApplicationRecordDataTypes(child_element, ar_package)
-            self.readImplementationDataTypes(child_element, ar_package)
-            self.readSwBaseTypes(child_element, ar_package)
-            self.readCompuMethods(child_element, ar_package)
-            self.readEcuAbstractionSwComponents(child_element, ar_package)
-            self.readApplicationSwComponentTypes(child_element, ar_package)
-            self.readComplexDeviceDriverSwComponentTypes(child_element, ar_package)
-            self.readSensorActuatorSwComponentType(child_element, ar_package)
-            self.readServiceSwComponentTypes(child_element, ar_package)
-            self.readCompositionSwComponentTypes(child_element, ar_package)
-            self.readBswModuleDescription(child_element, ar_package)
-            self.readBswModuleEntry(child_element, ar_package)
-            self.readSwcBswMappings(child_element, ar_package)
-            self.readBswImplementation(child_element, ar_package)
-            self.readSwcImplementation(child_element, ar_package)
-            self.readConstantSpecification(child_element, ar_package)
-            self.readDataConstr(child_element, ar_package)
-            self.readUnit(child_element, ar_package)
+
 
     def load(self, filename, document: AUTOSAR):
         self.logger.info("Load %s ..." % filename)
@@ -1349,4 +2075,5 @@ class ARXMLParser:
         if (self.getPureTagName(root.tag) != "AUTOSAR"):
             self._raiseError("Invalid ARXML file <%s>" % filename)
 
+        self.getAUTOSARInfo(root, document)
         self.readARPackages(root, document)