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

armodel/models/ar_package.py

@@ -1,12 +1,25 @@
-from typing import List
-
+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.lin_communication import LinUnconditionalFrame
+from .fibex.lin_topology import LinCluster
+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 .general_structure import Identifiable, ARObject, Referrable, CollectableElement, SwcBswMapping
-from .port_interface import SenderReceiverInterface, ClientServerInterface
-from .sw_component import SwComponentType, EcuAbstractionSwComponentType, AtomicSwComponentType, ApplicationSwComponentType, ServiceSwComponentType, CompositionSwComponentType, SensorActuatorSwComponentType
-from .datatype import ImplementationDataType, ApplicationDataType, DataTypeMappingSet, DataTypeMap, SwBaseType, ApplicationPrimitiveDataType, ApplicationRecordDataType
+from .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
+from .common_structure import ConstantSpecification, ModeDeclarationGroup
 from .implementation import BswImplementation, SwcImplementation, Implementation
 from .bsw_module_template import BswModuleDescription, BswModuleEntry
 from .global_constraints import DataConstr
@@ -16,14 +29,28 @@ class ARPackage(Identifiable, CollectableElement):
         Identifiable.__init__(self, parent, short_name)
         CollectableElement.__init__(self)
 
+        self._ar_packages = {}      # type: Dict[str, ARPackage]
+
     def getARPackages(self):    # type: (...) -> List[ARPackage]
-        return list(filter(lambda e: isinstance(e, ARPackage), self.elements.values()))
+        return list(sorted(self._ar_packages.values(), key= lambda a: a.short_name))
+        #return list(filter(lambda e: isinstance(e, ARPackage), self.elements.values()))
 
     def createARPackage(self, short_name: str):
+        '''
         if (short_name not in self.elements):
             ar_package = ARPackage(self, short_name)
             self.elements[short_name] = ar_package
         return self.elements[short_name]
+        '''
+        if short_name not in self._ar_packages:
+            ar_package = ARPackage(self, short_name)
+            self._ar_packages[short_name] = ar_package
+        return self._ar_packages[short_name]
+    
+    def getElement(self, short_name: str) -> Referrable:
+        if (short_name in self._ar_packages):
+            return self._ar_packages[short_name]
+        return CollectableElement.getElement(self, short_name)
 
     def createEcuAbstractionSwComponentType(self, short_name: str) -> EcuAbstractionSwComponentType:
         if (short_name not in self.elements):
@@ -32,10 +59,16 @@ class ARPackage(Identifiable, CollectableElement):
         return self.elements[short_name]
 
     def createApplicationSwComponentType(self, short_name: str) -> ApplicationSwComponentType:
-        if (short_name not in self.elements):
+        if short_name not in self.elements:
             sw_component = ApplicationSwComponentType(self, short_name)
             self.elements[short_name] = sw_component
         return self.elements[short_name]
+    
+    def createComplexDeviceDriverSwComponentType(self, short_name: str) -> ComplexDeviceDriverSwComponentType:
+        if short_name not in self.elements:
+            sw_component = ComplexDeviceDriverSwComponentType(self, short_name)
+            self.elements[short_name] = sw_component
+        return self.elements[short_name]
 
     def createServiceSwComponentType(self, short_name: str) -> ServiceSwComponentType:
         if (short_name not in self.elements):
@@ -129,8 +162,8 @@ class ARPackage(Identifiable, CollectableElement):
 
     def createSwcBswMapping(self, short_name: str) -> SwcBswMapping:
         if (short_name not in self.elements):
-            sw_component = SwcBswMapping(self, short_name)
-            self.elements[short_name] = sw_component
+            mapping = SwcBswMapping(self, short_name)
+            self.elements[short_name] = mapping
         return self.elements[short_name]
     
     def createConstantSpecification(self, short_name: str) -> ConstantSpecification:
@@ -141,24 +174,132 @@ class ARPackage(Identifiable, CollectableElement):
     
     def createDataConstr(self, short_name: str) -> DataConstr:
         if (short_name not in self.elements):
-            spec = DataConstr(self, short_name)
-            self.elements[short_name] = spec
+            constr = DataConstr(self, short_name)
+            self.elements[short_name] = constr
         return self.elements[short_name]
     
     def createUnit(self, short_name: str) -> Unit:
         if (short_name not in self.elements):
-            spec = Unit(self, short_name)
+            unit = Unit(self, short_name)
+            self.elements[short_name] = unit
+        return self.elements[short_name]
+    
+    def createEndToEndProtectionSet(self, short_name: str) -> EndToEndProtectionSet:
+        if (short_name not in self.elements):
+            spec = EndToEndProtectionSet(self, short_name)
             self.elements[short_name] = spec
         return self.elements[short_name]
-
+    
+    def createApplicationArrayDataType(self, short_name: str) -> ApplicationArrayDataType:
+        if (short_name not in self.elements):
+            data_type = ApplicationArrayDataType(self, short_name)
+            self.elements[short_name] = data_type
+        return self.elements[short_name]
+    
+    def createSwRecordLayout(self, short_name: str) -> SwRecordLayout:
+        if (short_name not in self.elements):
+            layout = SwRecordLayout(self, short_name)
+            self.elements[short_name] = layout
+        return self.elements[short_name]
+    
+    def createSwAddrMethod(self, short_name: str) -> SwAddrMethod:
+        if (short_name not in self.elements):
+            method = SwAddrMethod(self, short_name)
+            self.elements[short_name] = method
+        return self.elements[short_name]
+    
+    def createTriggerInterface(self, short_name: str) -> TriggerInterface:
+        if (short_name not in self.elements):
+            trigger_interface = TriggerInterface(self, short_name)
+            self.elements[short_name] = trigger_interface
+        return self.elements[short_name]
+    
+    def createModeDeclarationGroup(self, short_name: str) -> ModeDeclarationGroup:
+        if (short_name not in self.elements):
+            group = ModeDeclarationGroup(self, short_name)
+            self.elements[short_name] = group
+        return self.elements[short_name]
+    
+    def createModeSwitchInterface(self, short_name: str) -> ModeSwitchInterface:
+        if (short_name not in self.elements):
+            switch_interface = ModeSwitchInterface(self, short_name)
+            self.elements[short_name] = switch_interface
+        return self.elements[short_name]
+    
+    def createSwcTiming(self, short_name: str) -> SwcTiming:
+        if (short_name not in self.elements):
+            timing = SwcTiming(self, short_name)
+            self.elements[short_name] = timing
+        return self.elements[short_name]
+    
+    def createLinCluster(self, short_name: str) -> LinCluster:
+        if (short_name not in self.elements):
+            cluster = LinCluster(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)
+            self.elements[short_name] = frame
+        return self.elements[short_name]
+    
+    def createNmPdu(self, short_name: str) -> NmPdu:
+        if (short_name not in self.elements):
+            pdu = NmPdu(self, short_name)
+            self.elements[short_name] = pdu
+        return self.elements[short_name]
+    
+    def createNPdu(self, short_name: str) -> NPdu:
+        if (short_name not in self.elements):
+            pdu = NPdu(self, short_name)
+            self.elements[short_name] = pdu
+        return self.elements[short_name]
+    
+    def createDcmIPdu(self, short_name: str) -> DcmIPdu:
+        if (short_name not in self.elements):
+            pdu = DcmIPdu(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)
+            self.elements[short_name] = config
+        return self.elements[short_name]
+    
+    def createCanTpConfig(self, short_name: str) -> CanTpConfig:
+        if (short_name not in self.elements):
+            config = CanTpConfig(self, short_name)
+            self.elements[short_name] = config
+        return self.elements[short_name]
+    
+    def createCanFrame(self, short_name: str) -> CanFrame:
+        if (short_name not in self.elements):
+            frame = CanFrame(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)
+            self.elements[short_name] = gateway
+        return self.elements[short_name]
+    
+    def createISignal(self, short_name: str) -> ISignal:
+        if (short_name not in self.elements):
+            signal = ISignal(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
     def getApplicationPrimitiveDataTypes(self) -> List[ApplicationPrimitiveDataType]:
-        return list(filter(lambda a: isinstance(a, ApplicationPrimitiveDataType), self.elements.values()))
+        return list(sorted(filter(lambda a: isinstance(a, ApplicationPrimitiveDataType), self.elements.values()), key= lambda o:o.short_name))
     
     def getApplicationDataType(self) -> List[ApplicationDataType]:
         return list(sorted(filter(lambda a: isinstance(a, ApplicationDataType), self.elements.values()), key= lambda o:o.short_name))
 
     def getImplementationDataTypes(self) -> List[ImplementationDataType]:
-        return list(filter(lambda a: isinstance(a, ImplementationDataType), self.elements.values()))
+        return list(sorted(filter(lambda a: isinstance(a, ImplementationDataType), self.elements.values()), key= lambda o:o.short_name))
 
     def getSwBaseTypes(self) -> List[SwBaseType]:
         return list(filter(lambda a: isinstance(a, SwBaseType), self.elements.values()))
@@ -174,6 +315,9 @@ class ARPackage(Identifiable, CollectableElement):
 
     def getCompositionSwComponentTypes(self) -> List[CompositionSwComponentType]:
         return list(filter(lambda a : isinstance(a, CompositionSwComponentType), self.elements.values()))
+    
+    def getComplexDeviceDriverSwComponentTypes(self) -> List[ComplexDeviceDriverSwComponentType]:
+        return list(sorted(filter(lambda a : isinstance(a, ComplexDeviceDriverSwComponentType), self.elements.values()), key = lambda a: a.short_name))
 
     def getSenderReceiverInterfaces(self) -> List[SenderReceiverInterface]:
         return list(filter(lambda a : isinstance(a, SenderReceiverInterface), self.elements.values()))
@@ -213,8 +357,59 @@ class ARPackage(Identifiable, CollectableElement):
     
     def getUnits(self) -> List[Unit]:
         return list(filter(lambda a: isinstance(a, Unit), self.elements.values()))
+    
+    def getApplicationArrayDataTypes(self) -> List[ApplicationArrayDataType]:
+        return list(sorted(filter(lambda a : isinstance(a, ApplicationArrayDataType), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getSwRecordLayouts(self) -> List[SwRecordLayout]:
+        return list(sorted(filter(lambda a : isinstance(a, SwRecordLayout), self.elements.values()), key = lambda a: a.short_name))
 
-class AUTOSAR (CollectableElement):
+    def getSwAddrMethods(self) -> List[SwAddrMethod]:
+        return list(sorted(filter(lambda a : isinstance(a, SwAddrMethod), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getTriggerInterfaces(self) -> List[TriggerInterface]:
+        return list(sorted(filter(lambda a : isinstance(a, TriggerInterface), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getModeDeclarationGroups(self) -> List[ModeDeclarationGroup]:
+        return list(sorted(filter(lambda a : isinstance(a, ModeDeclarationGroup), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getModeSwitchInterfaces(self) -> List[ModeSwitchInterface]:
+        return list(sorted(filter(lambda a : isinstance(a, ModeSwitchInterface), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getSwcTimings(self) -> List[SwcTiming]:
+        return list(sorted(filter(lambda a : isinstance(a, SwcTiming), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getLinClusters(self) -> List[LinCluster]:
+        return list(sorted(filter(lambda a : isinstance(a, LinCluster), 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))
+    
+    def getNmPdus(self) -> List[NmPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, NmPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getNPdus(self) -> List[NPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, NPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getDcmIPdus(self) -> List[DcmIPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, DcmIPdu), 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))
+    
+    def getCanTpConfigs(self) -> List[CanTpConfig]:
+        return list(sorted(filter(lambda a : isinstance(a, CanTpConfig), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getCanFrames(self) -> List[CanFrame]:
+        return list(sorted(filter(lambda a : isinstance(a, CanFrame), 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))
+    
+class AUTOSAR (CollectableElement):        
     __instance = None
 
     @staticmethod
@@ -228,26 +423,35 @@ class AUTOSAR (CollectableElement):
             raise Exception("The AUTOSAR is singleton!")
         CollectableElement.__init__(self)
 
-        self.version = "4.3.0"
+        self.schema_location = ""
         self._appl_impl_type_maps = {}
         self._impl_appl_type_maps = {}
         AUTOSAR.__instance = self
 
+        self._ar_packages = {}          # type: Dict[str, ARPackage]
+
     @property
     def full_name(self):
         return ""
 
     def clear(self):
+        self._ar_packages = {}
         self.elements = {}
 
+    def getElement(self, short_name: str) -> Referrable:
+        if (short_name in self._ar_packages):
+            return self._ar_packages[short_name]
+        return CollectableElement.getElement(self, short_name)
+
     def getARPackages(self) -> List[ARPackage]:
-        return list(filter(lambda e: isinstance(e, ARPackage), self.elements.values()))
+        #return list(filter(lambda e: isinstance(e, ARPackage), self.elements.values()))
+        return list(sorted(self._ar_packages.values(), key= lambda a: a.short_name))
 
     def createARPackage(self, short_name: str) -> ARPackage:
-        if (short_name not in self.elements):
+        if (short_name not in self._ar_packages):
             ar_package = ARPackage(self, short_name)
-            self.elements[short_name] = ar_package
-        return self.elements[short_name]
+            self._ar_packages[short_name] = ar_package
+        return self._ar_packages[short_name]
 
     def find(self, referred_name: str) -> Referrable:
         short_name_list = referred_name.split("/")
@@ -264,11 +468,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.implementation_data_type_ref.value)
+                referred_type = self.find(data_type.sw_data_def_props.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.base_type_ref.value)
+                    referred_type = self.find(data_type.sw_data_def_props.sw_pointer_target_props.sw_data_def_props.baseTypeRef.value)
                     return self.getDataType(referred_type)
             return data_type
         else:

armodel/models/ar_ref.py

@@ -1,4 +1,5 @@
 from abc import ABCMeta
+from typing import List
 from .ar_object import ARObject
 
 class RefType(ARObject):
@@ -14,16 +15,34 @@ class TRefType(RefType):
 class AutosarVariableRef(ARObject):
     def __init__(self):
         super().__init__()
-        self.autosar_variable_iref = None
-        self.autosar_variable_in_impl_datatype = None # type: ArVariableInImplementationDataInstanceRef
+        self.autosar_variable_iref = None               # type: VariableInAtomicSWCTypeInstanceRef 
+        self.autosar_variable_in_impl_datatype = None   # type: ArVariableInImplementationDataInstanceRef
         self.local_variable_ref = None
 
+class AutosarParameterRef(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.autosar_parameter_iref = None          # type: ParameterInAtomicSWCTypeInstanceRef
+        self.local_parameter_ref = None             # type: RefType
+
 class AtpInstanceRef(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) == AtpInstanceRef:
             raise NotImplementedError("AtpInstanceRef is an abstract class.")
+        
+        super().__init__()
+
+class VariableInAtomicSWCTypeInstanceRef(AtpInstanceRef):
+    def __init__(self):
         super().__init__()
 
+        self.base_ref = None                            # type: RefType
+        self.context_data_prototype_ref = None          # type: RefType
+        self.port_prototype_ref = None                  # type: RefType
+        self.root_variable_data_prototype_ref = None    # type: RefType
+        self.target_data_prototype_ref = None           # type: RefType
+
 class PortInCompositionTypeInstanceRef(AtpInstanceRef, metaclass=ABCMeta):
     def __init__(self):
         if type(self) == PortInCompositionTypeInstanceRef:
@@ -95,7 +114,67 @@ class RModeInAtomicSwcInstanceRef(AtpInstanceRef):
     def __init__(self):
         super().__init__()
 
-        self.base_ref = None                                    # type: RefType
-        self.context_mode_declaration_group_prototype = None    # type: RefType
-        self.context_port = None                                # type: RefType
-        self.target_mode_declaration = None                     # type: RefType
+        self.base_ref = None                                        # type: RefType
+        self.context_mode_declaration_group_prototype_ref = None    # type: RefType
+        self.context_port_ref = None                                # type: RefType
+        self.target_mode_declaration_ref = None                     # type: RefType
+
+class ParameterInAtomicSWCTypeInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.base_ref = None                                        # type: RefType
+        self.context_data_prototype_ref = None                      # type: RefType
+        self.port_prototype_ref = None                              # type: RefType
+        self.root_parameter_data_prototype_ref = None               # type: RefType
+        self.target_data_prototype_ref = None                       # type: RefType
+
+class ApplicationCompositeElementInPortInterfaceInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.base_ref = None                                        # type: RefType
+        self.context_data_prototype_ref = None                      # type: RefType
+        self.root_data_prototype_ref = None                         # type: RefType
+        self.target_data_prototype_ref = None                       # type: RefType
+
+class InnerPortGroupInCompositionInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.baseRef = None                                        # type: RefType
+        self.contextRef = None                                     # type: RefType
+        self.targetRef = None                                      # type: RefType
+
+class VariableDataPrototypeInSystemInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.base_ref = None                                        # type: RefType
+        self.context_component_refs = []                            # type: List[RefType]
+        self.context_composition_ref = None                         # type: RefType
+        self.context_port_ref = None                                # type: RefType
+        self.target_data_prototype_ref = None                       # type: RefType 
+
+class RModeGroupInAtomicSWCInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.context_r_port = None                                  # type: RefType
+        self.target_mode_group = None                               # type: RefType
+
+    @property
+    def contextRPort(self) -> RefType:
+        return self.context_r_port
+    
+    @contextRPort.setter
+    def contextRPort(self, value: RefType):
+        self.context_r_port = value
+
+    @property
+    def targetModeGroup(self) -> RefType:
+        return self.target_mode_group
+    
+    @targetModeGroup.setter
+    def targetModeGroup(self, value: RefType):
+        self.target_mode_group = value