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

armodel/cli/arxml_dump_cli.py

@@ -2,9 +2,9 @@ import getopt
 import sys
 import logging
 
-from ..models import AUTOSAR, ARPackage, AtomicSwComponentType, VariableAccess, SwComponentType, DataTypeMappingSet
+from ..models import AUTOSAR, ARPackage, VariableAccess, SwComponentType, DataTypeMappingSet
 from ..models import SwcInternalBehavior, ImplementationDataType
-from ..models import BswModuleDescription, BswEvent, BswInternalBehavior, BswModuleEntity, BswModuleEntry
+from ..models import BswModuleDescription, BswInternalBehavior, BswModuleEntity, BswModuleEntry
 from ..models import PortPrototype, RPortPrototype, PPortPrototype
 from ..models import SenderReceiverInterface, ClientServerInterface
 from ..parser import ARXMLParser
@@ -21,26 +21,26 @@ def show_port(indent:int, port_prototype: PortPrototype):
     if (isinstance(port_prototype, RPortPrototype)):
         print("%s-RPort: %s (%s)" % (" " * indent, port_prototype.short_name, port_prototype.required_interface_tref.value))
         for client_com_spec in port_prototype.getClientComSpecs():
-            print("%s    : %s (ClientComSpec)" % (" " * (indent + 2), client_com_spec.operation_ref.value))
+            print("%s    : %s (ClientComSpec)" % (" " * (indent + 2), client_com_spec.operationRef.value))
         for com_spec in port_prototype.getNonqueuedReceiverComSpecs():
-            print("%s    : %s (NonqueuedReceiverComSpec)" % (" " * (indent + 2), com_spec.data_element_ref.value))
+            print("%s    : %s (NonqueuedReceiverComSpec)" % (" " * (indent + 2), com_spec.dataElementRef.value))
     elif (isinstance(port_prototype, PPortPrototype)):
         print("%s-PPort: %s (%s)" % (" " * indent, port_prototype.short_name, port_prototype.provided_interface_tref.value))
         for com_spec in port_prototype.getNonqueuedSenderComSpecs():
-            print("%s    : %s (NonqueuedSenderComSpec)" % (" " * (indent + 2), com_spec.data_element_ref.value))
+            print("%s    : %s (NonqueuedSenderComSpec)" % (" " * (indent + 2), com_spec.dataElementRef.value))
     else:
         raise ValueError("Unsupported Port prototype")
 
 def show_type(indent: int, data_type: ImplementationDataType):
     print("%s-Implementation Type: %s (%s)" % (" " * indent, data_type.short_name, data_type._parent.full_name))
     print("%s                    : %s" % (" " * indent, data_type.category))
-    if (data_type.sw_data_def_props != None):
-        if (data_type.sw_data_def_props.baseTypeRef != None):
-            base_type_ref = data_type.sw_data_def_props.baseTypeRef
+    if (data_type.swDataDefProps != None):
+        if (data_type.swDataDefProps.baseTypeRef != None):
+            base_type_ref = data_type.swDataDefProps.baseTypeRef
             print("%s                    : %s (%s)" % (" " * indent, base_type_ref.value, base_type_ref.dest))
             
-        if (data_type.sw_data_def_props.implementationDataTypeRef != None):
-            implementation_data_type_ref = data_type.sw_data_def_props.implementationDataTypeRef
+        if (data_type.swDataDefProps.implementationDataTypeRef != None):
+            implementation_data_type_ref = data_type.swDataDefProps.implementationDataTypeRef
             print("%s                    : %s (%s)" % (" " * indent, implementation_data_type_ref.value, implementation_data_type_ref.dest))
 
 def show_data_type_mapping(indent: int, mapping_set: DataTypeMappingSet):
@@ -92,7 +92,7 @@ def show_client_server_interface(indent: int, cs_interface: ClientServerInterfac
         print("%sOperation:%s" % (" " * (indent + 2), operation.short_name))
         for argument in operation.getArgumentDataPrototypes():
             print("%s         :%s (%s: %s)" % (" " * (indent + 2), argument.short_name, 
-                argument.direction, argument.type_tref.value))
+                argument.direction, argument.typeTRef.value))
 
 def show_bsw_internal_behavior(indent: int, behavior: BswInternalBehavior):
     document = AUTOSAR.getInstance()
@@ -107,8 +107,8 @@ def show_bsw_internal_behavior(indent: int, behavior: BswInternalBehavior):
         print("%s-%s: %s" % (" " * (indent + 4), "StartsOnEventRef", event.startsOnEventRef.value))
         starts_on_event = document.find(event.startsOnEventRef.value) # type: BswModuleEntity
         print("%s-%s: %s" % (" " * (indent + 4), "StartsOnEvent", starts_on_event.short_name))
-        print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntryRef", starts_on_event.implemented_entry_ref.value))
-        implemented_entry = document.find(starts_on_event.implemented_entry_ref.value) # type: BswModuleEntry
+        print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntryRef", starts_on_event.implementedEntryRef.value))
+        implemented_entry = document.find(starts_on_event.implementedEntryRef.value) # type: BswModuleEntry
         print("%s-%s: %s" % (" " * (indent + 4), "ImplementedEntry", implemented_entry.short_name))
         print("%s-%s: %d" % (" " * (indent + 6), "Service Id", implemented_entry.service_id))
 

armodel/cli/memory_section_cli.py

@@ -0,0 +1,76 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+
+from armodel import AUTOSAR
+from armodel.parser import ARXMLParser
+from ..lib import InputFileParser, SystemSignalAnalyzer
+
+def main():
+    version = pkg_resources.require("armodel")[0].version
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-v", "--verbose", required= False, help= "Print debug information", action= "store_true")
+    ap.add_argument("-f", "--format", required= False, help= "Specify the short or long name of Sw-C. [short|long]")
+    
+    ap.add_argument("INPUT", help = "The path of AUTOSAR XML", nargs='+')
+    ap.add_argument("")
+
+    args = ap.parse_args()
+
+    logger = logging.getLogger()
+    
+    formatter = logging.Formatter('[%(levelname)s] : %(message)s')
+
+    stdout_handler = logging.StreamHandler(sys.stderr)
+    stdout_handler.setFormatter(formatter)
+
+    #base_path = os.path.dirname(args.Output)
+    log_file = os.path.join(".", 'system-signals.log')
+
+    if os.path.exists(log_file):
+        os.remove(log_file)
+
+    file_handler = logging.FileHandler(log_file)
+    file_handler.setFormatter(formatter)
+
+    logger.setLevel(logging.DEBUG)
+    file_handler.setLevel(logging.DEBUG)
+
+    if args.verbose:
+        stdout_handler.setLevel(logging.DEBUG)
+        
+    else:
+        stdout_handler.setLevel(logging.INFO)
+
+    logger.addHandler(file_handler)
+    logger.addHandler(stdout_handler)    
+
+    try:
+        parser = InputFileParser(args.INPUT)
+        filenames = parser.parse()
+
+        document = AUTOSAR().getInstance()
+        parser = ARXMLParser({'warning': True})
+
+        format = "short"
+        if args.format is not None and args.format.lower() == "long":
+            format = "long"
+
+        for filename in filenames:
+            parser.load(filename, document)
+
+        analyzer = SystemSignalAnalyzer()
+        analyzer.import_data(document)
+        analyzer.print_out({
+            'format': format,
+        })
+        
+    except Exception as e:
+        print(e)
+        #raise e
+
+if __name__ == "__main__":
+    main()

armodel/cli/system_signal_cli.py

@@ -0,0 +1,74 @@
+import argparse
+import pkg_resources
+import logging
+import sys
+import os.path
+
+from armodel import AUTOSAR
+from armodel.parser import ARXMLParser
+from ..lib import InputFileParser, SystemSignalAnalyzer
+
+def main():
+    version = pkg_resources.require("armodel")[0].version
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-v", "--verbose", required= False, help= "Print debug information", action= "store_true")
+    ap.add_argument("-f", "--format", required= False, help= "Specify the name format of SW-C. [short|full]")
+    ap.add_argument("INPUT", help = "The path of AUTOSAR XML", nargs='+')
+
+    args = ap.parse_args()
+
+    logger = logging.getLogger()
+    
+    formatter = logging.Formatter('[%(levelname)s] : %(message)s')
+
+    stdout_handler = logging.StreamHandler(sys.stderr)
+    stdout_handler.setFormatter(formatter)
+
+    #base_path = os.path.dirname(args.Output)
+    log_file = os.path.join(".", 'system-signals.log')
+
+    if os.path.exists(log_file):
+        os.remove(log_file)
+
+    file_handler = logging.FileHandler(log_file)
+    file_handler.setFormatter(formatter)
+
+    logger.setLevel(logging.DEBUG)
+    file_handler.setLevel(logging.DEBUG)
+
+    if args.verbose:
+        stdout_handler.setLevel(logging.DEBUG)
+        
+    else:
+        stdout_handler.setLevel(logging.INFO)
+
+    logger.addHandler(file_handler)
+    logger.addHandler(stdout_handler)    
+
+    try:
+        parser = InputFileParser(args.INPUT)
+        filenames = parser.parse()
+
+        document = AUTOSAR().getInstance()
+        parser = ARXMLParser({'warning': True})
+
+        format = "short"
+        if args.format is not None and args.format.lower() == "full":
+            format = "full"
+
+        for filename in filenames:
+            parser.load(filename, document)
+
+        analyzer = SystemSignalAnalyzer()
+        analyzer.import_data(document)
+        analyzer.print_out({
+            'format': format,
+        })
+        
+    except Exception as e:
+        print(e)
+        #raise e
+
+if __name__ == "__main__":
+    main()

armodel/lib/__init__.py

@@ -1,3 +1,4 @@
 
 from .cli_args_parser import InputFileParser
-from .sw_component import SwComponentAnalyzer
+from .sw_component import SwComponentAnalyzer
+from .system_signal import SystemSignalAnalyzer

armodel/lib/system_signal.py

@@ -0,0 +1,37 @@
+import logging
+from typing import List
+
+from ..models.ar_package import AUTOSAR, ARPackage
+from ..models.fibex.fibex_core.core_communication import SystemSignal
+
+class SystemSignalAnalyzer:
+    def __init__(self) -> None:
+        self.system_signals = []      # type: List[SystemSignal]
+
+    def add_system_signal(self, signal: SystemSignal):
+        self.system_signals.append(signal)
+
+    def get_system_signals(self) -> List[SystemSignal]:
+        return self.system_signals
+    
+    def parse_pkg(self, parent: ARPackage):
+        for pkg in parent.getARPackages():
+            self.parse_pkg(pkg)
+        for signal in parent.getSystemSignals():
+            
+            self.add_system_signal(signal)
+
+    def import_data(self, document: AUTOSAR):
+        for pkg in document.getARPackages():
+            self.parse_pkg(pkg)
+
+    def print_out(self, option = {}):
+        logger = logging.getLogger()
+
+        logger.info("== SYSTEM SIGNAL LIST ==")
+
+        for signal in sorted(self.system_signals, key = lambda o: o.short_name):
+            if option['format'] == 'full':
+                logger.info("%s" % signal.full_name)
+            else:
+                logger.info("%s" % signal.short_name)

armodel/models/__init__.py

@@ -8,12 +8,15 @@ from .ar_ref import *
 from .datatype import *
 from .port_prototype import * 
 from .data_prototype import *
-from .data_dictionary import *
-from .port_interface import *
+from .m2.msr.asam_hdo.units import *
+from .m2.msr.data_dictionary.data_def_properties import *
+from .m2.msr.data_dictionary.auxillary_objects import *
+from .m2.autosar_templates.sw_component_template.port_interface import *
 from .m2_msr import *
 from .implementation import *
 from .bsw_module_template import *
 from .communication import *
 from .calibration import *
 from .global_constraints import *
-from .unit import *
+from .m2.msr.asam_hdo.units import *
+from .m2.autosar_templates.sw_component_template import *

armodel/models/annotation.py

@@ -1,8 +1,9 @@
 
 from abc import ABCMeta
 
+from .m2.msr.documentation.block_elements import DocumentationBlock
 from .multilanguage_data import MultilanguageLongName
-from .ar_object import ARObject
+from .ar_object import ARLiteral, ARObject
 
 
 class GeneralAnnotation(ARObject, metaclass=ABCMeta):
@@ -10,10 +11,33 @@ class GeneralAnnotation(ARObject, metaclass=ABCMeta):
         if type(self) == ARObject:
             raise NotImplementedError("GeneralAnnotation is an abstract class.")
         
-        self.label = None       # type: MultilanguageLongName
-
         super().__init__()
 
+        self.annotationOrigin = None        # type: ARLiteral
+        self.annotationText = None          # type: DocumentationBlock
+        self.label = None                   # type: MultilanguageLongName
+
+    def getAnnotationOrigin(self) -> ARLiteral:
+        return self.annotationOrigin
+
+    def setAnnotationOrigin(self, value: ARLiteral):
+        self.annotationOrigin = value
+        return self
+    
+    def getAnnotationText(self) -> DocumentationBlock:
+        return self.annotationText
+
+    def setAnnotationText(self, value: DocumentationBlock):
+        self.annotationText = value
+        return self
+
+    def getLabel(self) -> MultilanguageLongName:
+        return self.label
+
+    def setLabel(self, value: MultilanguageLongName):
+        self.label = value
+        return  self
+
 class Annotation(GeneralAnnotation):
     def __init__(self):
         super().__init__()

armodel/models/ar_object.py

@@ -73,10 +73,21 @@ class ARNumerical(ARType):
         self._text = None                   # type: str
 
     def _convertStringToNumberValue(self, value: str) -> int:
-        m = re.match(r"0x([0-9a-f]+)", value, re.I)
-        if (m):
-            return int(m.group(1), 16)
-        return int(value)
+        try:
+            if value == 'true':
+                return 1
+            elif value == 'false':
+                return 0
+            else:
+                m = re.match(r"0x([0-9a-f]+)", value, re.I)
+                if m:
+                    return int(m.group(1), 16)
+                m = re.match(r"\d+\.\d+", value)
+                if m:
+                    return float(value)
+                return int(value)
+        except:
+            raise ValueError("Invalid Numerical Type <%s>" % value)
     
     @property
     def value(self) -> int:
@@ -118,7 +129,7 @@ class ARPositiveInteger(ARNumerical):
         else:
             raise ValueError("Unsupported Type <%s>", type(val))
 
-class ARFloat(ARType):
+class ARFloat(ARNumerical):
     def __init__(self) -> None:
         super().__init__()
 
@@ -136,7 +147,8 @@ class ARFloat(ARType):
             self._value = val * 1.0
         elif isinstance(val, str):
             self._text = val
-            self._value = float(val)
+            #self._value = float(val)
+            self._value = self._convertStringToNumberValue(val)
         else:
             raise ValueError("Unsupported Type <%s>", type(val))
 

armodel/models/ar_package.py

@@ -1,25 +1,30 @@
 from typing import Dict, List
 
-from armodel.models.fibex.can_communication import CanFrame
-from armodel.models.fibex.fibex_4_multiplatform import Gateway
-
-from .system_template.transport_protocols import CanTpConfig
-from .system_template.network_management import NmConfig
-from .fibex.fibex_core import DcmIPdu, ISignal, NPdu, NmPdu
+from .fibex.fibex_core.core_topology import EcuInstance, CanCluster, LinCluster
+from .fibex.fibex_core.core_communication import ISignalGroup, ISignalIPdu, ISignalIPduGroup, SecuredIPdu, SystemSignal, DcmIPdu, ISignal, NPdu, NmPdu, SystemSignalGroup
+from .fibex.can_communication import CanFrame
+from .fibex.fibex_4_multiplatform import Gateway
 from .fibex.lin_communication import LinUnconditionalFrame
-from .fibex.lin_topology import LinCluster
+
+from .m2.msr.asam_hdo.units import PhysicalDimension
+from .m2.msr.data_dictionary.auxillary_objects import SwAddrMethod
+from .m2.autosar_templates.common_structure import ConstantSpecification
+from .m2.autosar_templates.ecuc_description_template import EcucModuleConfigurationValues, EcucValueCollection
+from .m2.autosar_templates.system_template import System
+from .m2.autosar_templates.system_template.transport_protocols import CanTpConfig
+from .m2.autosar_templates.system_template.network_management import NmConfig
+
 from .timing import SwcTiming
-from .data_dictionary import SwAddrMethod
 from .record_layout import SwRecordLayout
 from .end_to_end_protection import EndToEndProtectionSet
-from .unit import Unit
+from .m2.msr.asam_hdo.units import Unit
 from .general_structure import Identifiable, ARObject, Referrable, CollectableElement, SwcBswMapping
-from .port_interface import ModeSwitchInterface, SenderReceiverInterface, ClientServerInterface, TriggerInterface
+from .m2.autosar_templates.sw_component_template.port_interface import ModeSwitchInterface, SenderReceiverInterface, ClientServerInterface, TriggerInterface
 from .sw_component import SwComponentType, EcuAbstractionSwComponentType, AtomicSwComponentType, ApplicationSwComponentType
 from .sw_component import ServiceSwComponentType, CompositionSwComponentType, SensorActuatorSwComponentType, ComplexDeviceDriverSwComponentType
 from .datatype import ApplicationArrayDataType, ImplementationDataType, ApplicationDataType, DataTypeMappingSet, DataTypeMap, SwBaseType, ApplicationPrimitiveDataType, ApplicationRecordDataType
 from .m2_msr import CompuMethod
-from .common_structure import ConstantSpecification, ModeDeclarationGroup
+from .common_structure import ModeDeclarationGroup
 from .implementation import BswImplementation, SwcImplementation, Implementation
 from .bsw_module_template import BswModuleDescription, BswModuleEntry
 from .global_constraints import DataConstr
@@ -238,6 +243,12 @@ class ARPackage(Identifiable, CollectableElement):
             self.elements[short_name] = cluster
         return self.elements[short_name]
     
+    def createCanCluster(self, short_name: str) -> CanCluster:
+        if (short_name not in self.elements):
+            cluster = CanCluster(self, short_name)
+            self.elements[short_name] = cluster
+        return self.elements[short_name]
+    
     def createLinUnconditionalFrame(self, short_name: str) -> LinUnconditionalFrame:
         if (short_name not in self.elements):
             frame = LinUnconditionalFrame(self, short_name)
@@ -262,6 +273,12 @@ class ARPackage(Identifiable, CollectableElement):
             self.elements[short_name] = pdu
         return self.elements[short_name]
     
+    def createSecuredIPdu(self, short_name: str) -> SecuredIPdu:
+        if (short_name not in self.elements):
+            pdu = SecuredIPdu(self, short_name)
+            self.elements[short_name] = pdu
+        return self.elements[short_name]
+    
     def createNmConfig(self, short_name: str) -> NmConfig:
         if (short_name not in self.elements):
             config = NmConfig(self, short_name)
@@ -280,6 +297,12 @@ class ARPackage(Identifiable, CollectableElement):
             self.elements[short_name] = frame
         return self.elements[short_name]
     
+    def createEcuInstance(self, short_name: str) -> EcuInstance:
+        if (short_name not in self.elements):
+            frame = EcuInstance(self, short_name)
+            self.elements[short_name] = frame
+        return self.elements[short_name]
+    
     def createGateway(self, short_name: str) -> Gateway:
         if (short_name not in self.elements):
             gateway = Gateway(self, short_name)
@@ -292,6 +315,60 @@ class ARPackage(Identifiable, CollectableElement):
             self.elements[short_name] = signal
         return self.elements[short_name]
     
+    def createSystemSignal(self, short_name: str) -> SystemSignal:
+        if (short_name not in self.elements):
+            signal = SystemSignal(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createSystemSignalGroup(self, short_name: str) -> SystemSignalGroup:
+        if (short_name not in self.elements):
+            signal = SystemSignalGroup(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createISignalIPdu(self, short_name: str) -> ISignalIPdu:
+        if (short_name not in self.elements):
+            signal = ISignalIPdu(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createEcucValueCollection(self, short_name: str) -> EcucValueCollection:
+        if (short_name not in self.elements):
+            signal = EcucValueCollection(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createEcucModuleConfigurationValues(self, short_name: str) -> EcucModuleConfigurationValues:
+        if (short_name not in self.elements):
+            signal = EcucModuleConfigurationValues(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createPhysicalDimension(self, short_name: str) -> PhysicalDimension:
+        if (short_name not in self.elements):
+            signal = PhysicalDimension(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createISignalGroup(self, short_name: str) -> ISignalGroup:
+        if (short_name not in self.elements):
+            signal = ISignalGroup(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createISignalIPduGroup(self, short_name: str) -> ISignalIPduGroup:
+        if (short_name not in self.elements):
+            signal = ISignalIPduGroup(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
+    def createSystem(self, short_name: str) -> System:
+        if (short_name not in self.elements):
+            signal = System(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
     def getApplicationPrimitiveDataTypes(self) -> List[ApplicationPrimitiveDataType]:
         return list(sorted(filter(lambda a: isinstance(a, ApplicationPrimitiveDataType), self.elements.values()), key= lambda o:o.short_name))
     
@@ -382,6 +459,9 @@ class ARPackage(Identifiable, CollectableElement):
     def getLinClusters(self) -> List[LinCluster]:
         return list(sorted(filter(lambda a : isinstance(a, LinCluster), self.elements.values()), key = lambda a: a.short_name))
     
+    def getCanClusters(self) -> List[CanCluster]:
+        return list(sorted(filter(lambda a : isinstance(a, CanCluster), self.elements.values()), key = lambda a: a.short_name))
+    
     def getLinUnconditionalFrames(self) -> List[LinUnconditionalFrame]:
         return list(sorted(filter(lambda a : isinstance(a, LinUnconditionalFrame), self.elements.values()), key = lambda a: a.short_name))
     
@@ -394,6 +474,9 @@ class ARPackage(Identifiable, CollectableElement):
     def getDcmIPdus(self) -> List[DcmIPdu]:
         return list(sorted(filter(lambda a : isinstance(a, DcmIPdu), self.elements.values()), key = lambda a: a.short_name))
     
+    def getSecuredIPdus(self) -> List[SecuredIPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, SecuredIPdu), self.elements.values()), key = lambda a: a.short_name))
+    
     def getNmConfigs(self) -> List[NmConfig]:
         return list(sorted(filter(lambda a : isinstance(a, NmConfig), self.elements.values()), key = lambda a: a.short_name))
     
@@ -403,12 +486,39 @@ class ARPackage(Identifiable, CollectableElement):
     def getCanFrames(self) -> List[CanFrame]:
         return list(sorted(filter(lambda a : isinstance(a, CanFrame), self.elements.values()), key = lambda a: a.short_name))
     
+    def getEcuInstances(self) -> List[EcuInstance]:
+        return list(sorted(filter(lambda a : isinstance(a, EcuInstance), self.elements.values()), key = lambda a: a.short_name))
+    
     def getGateways(self) -> List[Gateway]:
         return list(sorted(filter(lambda a : isinstance(a, Gateway), self.elements.values()), key = lambda a: a.short_name))
     
     def getISignals(self) -> List[ISignal]:
         return list(sorted(filter(lambda a : isinstance(a, ISignal), self.elements.values()), key = lambda a: a.short_name))
     
+    def getEcucValueCollections(self) -> List[EcucValueCollection]:
+        return list(sorted(filter(lambda a : isinstance(a, EcucValueCollection), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getEcucModuleConfigurationValues(self) -> List[EcucModuleConfigurationValues]:
+        return list(sorted(filter(lambda a : isinstance(a, EcucModuleConfigurationValues), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getEcucModuleConfigurationValues(self) -> List[PhysicalDimension]:
+        return list(sorted(filter(lambda a : isinstance(a, PhysicalDimension), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getISignalGroups(self) -> List[ISignalGroup]:
+        return list(sorted(filter(lambda a : isinstance(a, ISignalGroup), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getSystemSignals(self) -> List[SystemSignal]:
+        return list(sorted(filter(lambda a : isinstance(a, SystemSignal), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getSystemSignalGroups(self) -> List[SystemSignalGroup]:
+        return list(sorted(filter(lambda a : isinstance(a, SystemSignalGroup), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getISignalIPdus(self) -> List[ISignalIPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, ISignalIPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getSystems(self) -> List[System]:
+        return list(sorted(filter(lambda a : isinstance(a, System), self.elements.values()), key = lambda a: a.short_name))
+    
 class AUTOSAR (CollectableElement):        
     __instance = None
 
@@ -468,11 +578,11 @@ class AUTOSAR (CollectableElement):
     def getDataType(self, data_type: ImplementationDataType) -> ImplementationDataType:
         if (isinstance(data_type, ImplementationDataType) or isinstance(data_type, SwBaseType)):
             if (data_type.category == ImplementationDataType.CATEGORY_TYPE_REFERENCE):
-                referred_type = self.find(data_type.sw_data_def_props.implementationDataTypeRef.value)
+                referred_type = self.find(data_type.swDataDefProps.implementationDataTypeRef.value)
                 return self.getDataType(referred_type)
             if (data_type.category == ImplementationDataType.CATEGORY_DATA_REFERENCE):
-                if (data_type.sw_data_def_props.sw_pointer_target_props.target_category == "VALUE"):
-                    referred_type = self.find(data_type.sw_data_def_props.sw_pointer_target_props.sw_data_def_props.baseTypeRef.value)
+                if (data_type.swDataDefProps.swPointerTargetProps.target_category == "VALUE"):
+                    referred_type = self.find(data_type.swDataDefProps.swPointerTargetProps.sw_data_def_props.baseTypeRef.value)
                     return self.getDataType(referred_type)
             return data_type
         else: