armodel 1.6.1__py3-none-any.whl → 1.6.3__py3-none-any.whl

armodel/models/{ar_package.py → M2/AUTOSARTemplates/GenericStructure/GeneralTemplateClasses/ARPackage.py}

@@ -1,36 +1,40 @@
-from typing import Dict, List
+from armodel.models.M2.AUTOSARTemplates.BswModuleTemplate.BswOverview import BswModuleDescription
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Implementation import Implementation
+from armodel.models.M2.AUTOSARTemplates.BswModuleTemplate.BswImplementation import BswImplementation
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import CollectableElement
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, Referrable
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationDataType, ApplicationPrimitiveDataType, ApplicationRecordDataType
+from armodel.models.M2.MSR.AsamHdo.BaseTypes import SwBaseType
+from armodel.models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleEntry
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.ModeDeclaration import ModeDeclarationGroup
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import DataTypeMappingSet
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionSet
+from armodel.models.fibex.can_communication import CanFrame
+from armodel.models.fibex.fibex_4_multiplatform import Gateway
+from armodel.models.fibex.fibex_core.core_communication import DcmIPdu, ISignal, ISignalGroup, ISignalIPdu, ISignalIPduGroup, NPdu, NmPdu, SecuredIPdu, SystemSignal, SystemSignalGroup
+from armodel.models.fibex.fibex_core.core_topology import CanCluster, EcuInstance, LinCluster
+from armodel.models.fibex.lin_communication import LinUnconditionalFrame
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping
+from armodel.models.M2.MSR.AsamHdo.Constraints.GlobalConstraints import DataConstr
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.SwcImplementation import SwcImplementation
+from armodel.models.M2.AUTOSARTemplates.CommonStructure import ConstantSpecification
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
+from armodel.models.M2.AUTOSARTemplates.ecuc_description_template import EcucModuleConfigurationValues, EcucValueCollection
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.Components import SwComponentType
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import CompositionSwComponentType
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.port_interface import ClientServerInterface, ModeSwitchInterface, ParameterInterface, SenderReceiverInterface, TriggerInterface
+from armodel.models.M2.AUTOSARTemplates.SystemTemplate import System
+from armodel.models.M2.AUTOSARTemplates.SystemTemplate.network_management import NmConfig
+from armodel.models.M2.AUTOSARTemplates.SystemTemplate.transport_protocols import CanTpConfig
+from armodel.models.M2.MSR.AsamHdo.Units import PhysicalDimension, Unit
+from armodel.models.M2.MSR.DataDictionary.AuxillaryObjects import SwAddrMethod
+from armodel.models.M2.MSR.AsamHdo.ComputationMethod import CompuMethod
+from armodel.models.M2.MSR.DataDictionary.RecordLayout import SwRecordLayout
+from armodel.models.sw_component import ApplicationSwComponentType, AtomicSwComponentType, ComplexDeviceDriverSwComponentType, EcuAbstractionSwComponentType, SensorActuatorSwComponentType, ServiceSwComponentType
+from armodel.models.timing import SwcTiming
 
-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 .m2.msr.asam_hdo.units import PhysicalDimension, Unit
-from .m2.msr.data_dictionary.auxillary_objects import SwAddrMethod
-from .m2.autosar_templates.common_structure import ConstantSpecification
-from .m2.autosar_templates.common_structure.implementation_data_types import ImplementationDataType
-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 .m2.autosar_templates.sw_component_template.composition import CompositionSwComponentType
-from .m2.autosar_templates.sw_component_template.port_interface import ClientServerInterface, ModeSwitchInterface, ParameterInterface, SenderReceiverInterface, TriggerInterface
-from .m2.autosar_templates.sw_component_template.components import SwComponentType
-
-from .timing import SwcTiming
-from .record_layout import SwRecordLayout
-from .end_to_end_protection import EndToEndProtectionSet
-from .general_structure import Identifiable, ARObject, Referrable, CollectableElement, SwcBswMapping
-
-from .sw_component import EcuAbstractionSwComponentType, AtomicSwComponentType, ApplicationSwComponentType
-from .sw_component import ServiceSwComponentType, SensorActuatorSwComponentType, ComplexDeviceDriverSwComponentType
-from .datatype import ApplicationArrayDataType, ApplicationDataType, DataTypeMappingSet, DataTypeMap, SwBaseType, ApplicationPrimitiveDataType, ApplicationRecordDataType
-from .m2_msr import CompuMethod
-from .common_structure import ModeDeclarationGroup
-from .implementation import BswImplementation, SwcImplementation, Implementation
-from .bsw_module_template import BswModuleDescription, BswModuleEntry
-from .global_constraints import DataConstr
+from typing import Dict, List
 
 class ARPackage(Identifiable, CollectableElement):
     def __init__(self, parent: ARObject, short_name: str):
@@ -54,12 +58,12 @@ class ARPackage(Identifiable, CollectableElement):
             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):
             sw_component = EcuAbstractionSwComponentType(self, short_name)
@@ -71,7 +75,7 @@ class ARPackage(Identifiable, CollectableElement):
             sw_component = ApplicationSwComponentType(self, short_name)
             self.addElement(sw_component)
         return self.getElement(short_name)
-    
+
     def createComplexDeviceDriverSwComponentType(self, short_name: str) -> ComplexDeviceDriverSwComponentType:
         if short_name not in self.elements:
             sw_component = ComplexDeviceDriverSwComponentType(self, short_name)
@@ -83,7 +87,7 @@ class ARPackage(Identifiable, CollectableElement):
             sw_component = ServiceSwComponentType(self, short_name)
             self.addElement(sw_component)
         return self.getElement(short_name)
-    
+
     def createSensorActuatorSwComponentType(self, short_name: str) -> SensorActuatorSwComponentType:
         if (short_name not in self.elements):
             sw_component = SensorActuatorSwComponentType(self, short_name)
@@ -101,7 +105,7 @@ class ARPackage(Identifiable, CollectableElement):
             sr_interface = SenderReceiverInterface(self, short_name)
             self.addElement(sr_interface)
         return self.getElement(short_name)
-    
+
     def createParameterInterface(self, short_name: str) -> ParameterInterface:
         if (short_name not in self.elements):
             sr_interface = ParameterInterface(self, short_name)
@@ -167,7 +171,7 @@ class ARPackage(Identifiable, CollectableElement):
             impl = BswImplementation(self, short_name)
             self.addElement(impl)
         return self.getElement(short_name)
-    
+
     def createSwcImplementation(self, short_name: str) -> SwcImplementation:
         if (short_name not in self.elements):
             impl = SwcImplementation(self, short_name)
@@ -179,208 +183,208 @@ class ARPackage(Identifiable, CollectableElement):
             mapping = SwcBswMapping(self, short_name)
             self.addElement(mapping)
         return self.getElement(short_name)
-    
+
     def createConstantSpecification(self, short_name: str) -> ConstantSpecification:
         if (short_name not in self.elements):
             spec = ConstantSpecification(self, short_name)
             self.addElement(spec)
         return self.getElement(short_name)
-    
+
     def createDataConstr(self, short_name: str) -> DataConstr:
         if (short_name not in self.elements):
             constr = DataConstr(self, short_name)
             self.addElement(constr)
         return self.getElement(short_name)
-    
+
     def createUnit(self, short_name: str) -> Unit:
         if (short_name not in self.elements):
             unit = Unit(self, short_name)
             self.addElement(unit)
         return self.getElement(short_name)
-    
+
     def createEndToEndProtectionSet(self, short_name: str) -> EndToEndProtectionSet:
         if (short_name not in self.elements):
             e2d_set = EndToEndProtectionSet(self, short_name)
             self.addElement(e2d_set)
         return self.getElement(short_name)
-    
+
     def createApplicationArrayDataType(self, short_name: str) -> ApplicationArrayDataType:
         if (short_name not in self.elements):
             data_type = ApplicationArrayDataType(self, short_name)
             self.addElement(data_type)
         return self.getElement(short_name)
-    
+
     def createSwRecordLayout(self, short_name: str) -> SwRecordLayout:
         if (short_name not in self.elements):
             layout = SwRecordLayout(self, short_name)
             self.addElement(layout)
         return self.getElement(short_name)
-    
+
     def createSwAddrMethod(self, short_name: str) -> SwAddrMethod:
         if (short_name not in self.elements):
             method = SwAddrMethod(self, short_name)
             self.addElement(method)
         return self.getElement(short_name)
-    
+
     def createTriggerInterface(self, short_name: str) -> TriggerInterface:
         if (short_name not in self.elements):
             trigger_interface = TriggerInterface(self, short_name)
             self.addElement(trigger_interface)
         return trigger_interface
-    
+
     def createModeDeclarationGroup(self, short_name: str) -> ModeDeclarationGroup:
         if (short_name not in self.elements):
             group = ModeDeclarationGroup(self, short_name)
             self.addElement(group)
         return self.getElement(short_name)
-    
+
     def createModeSwitchInterface(self, short_name: str) -> ModeSwitchInterface:
         if (short_name not in self.elements):
             switch_interface = ModeSwitchInterface(self, short_name)
             self.addElement(switch_interface)
         return self.getElement(short_name)
-    
+
     def createSwcTiming(self, short_name: str) -> SwcTiming:
         if (short_name not in self.elements):
             timing = SwcTiming(self, short_name)
             self.addElement(timing)
         return self.getElement(short_name)
-    
+
     def createLinCluster(self, short_name: str) -> LinCluster:
         if (short_name not in self.elements):
             cluster = LinCluster(self, short_name)
             self.addElement(cluster)
         return self.getElement(short_name)
-    
+
     def createCanCluster(self, short_name: str) -> CanCluster:
         if (short_name not in self.elements):
             cluster = CanCluster(self, short_name)
             self.addElement(cluster)
         return self.getElement(short_name)
-    
+
     def createLinUnconditionalFrame(self, short_name: str) -> LinUnconditionalFrame:
         if (short_name not in self.elements):
             frame = LinUnconditionalFrame(self, short_name)
             self.addElement(frame)
         return self.getElement(short_name)
-    
+
     def createNmPdu(self, short_name: str) -> NmPdu:
         if (short_name not in self.elements):
             element = NmPdu(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createNPdu(self, short_name: str) -> NPdu:
         if (short_name not in self.elements):
             element = NPdu(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createDcmIPdu(self, short_name: str) -> DcmIPdu:
         if (short_name not in self.elements):
             element = DcmIPdu(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createSecuredIPdu(self, short_name: str) -> SecuredIPdu:
         if (short_name not in self.elements):
             element = SecuredIPdu(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createNmConfig(self, short_name: str) -> NmConfig:
         if (short_name not in self.elements):
             element = NmConfig(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createCanTpConfig(self, short_name: str) -> CanTpConfig:
         if (short_name not in self.elements):
             element = CanTpConfig(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createCanFrame(self, short_name: str) -> CanFrame:
         if (short_name not in self.elements):
             element = CanFrame(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createEcuInstance(self, short_name: str) -> EcuInstance:
         if (short_name not in self.elements):
             element = EcuInstance(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createGateway(self, short_name: str) -> Gateway:
         if (short_name not in self.elements):
             element = Gateway(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createISignal(self, short_name: str) -> ISignal:
         if (short_name not in self.elements):
             element = ISignal(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createSystemSignal(self, short_name: str) -> SystemSignal:
         if (short_name not in self.elements):
             element = SystemSignal(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createSystemSignalGroup(self, short_name: str) -> SystemSignalGroup:
         if (short_name not in self.elements):
             element = SystemSignalGroup(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createISignalIPdu(self, short_name: str) -> ISignalIPdu:
         if (short_name not in self.elements):
             element = ISignalIPdu(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createEcucValueCollection(self, short_name: str) -> EcucValueCollection:
         if (short_name not in self.elements):
             element = EcucValueCollection(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createEcucModuleConfigurationValues(self, short_name: str) -> EcucModuleConfigurationValues:
         if (short_name not in self.elements):
             element = EcucModuleConfigurationValues(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createPhysicalDimension(self, short_name: str) -> PhysicalDimension:
         if (short_name not in self.elements):
             element = PhysicalDimension(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createISignalGroup(self, short_name: str) -> ISignalGroup:
         if (short_name not in self.elements):
             element = ISignalGroup(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createISignalIPduGroup(self, short_name: str) -> ISignalIPduGroup:
         if (short_name not in self.elements):
             element = ISignalIPduGroup(self, short_name)
             self.addElement(element)
         return self.getElement(short_name)
-    
+
     def createSystem(self, short_name: str) -> System:
         if (short_name not in self.elements):
             element = System(self, short_name)
             self.addElement(element)
         return self.getElement(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))
-    
+
     def getApplicationDataType(self) -> List[ApplicationDataType]:
         return list(sorted(filter(lambda a: isinstance(a, ApplicationDataType), self.elements.values()), key= lambda o:o.short_name))
 
@@ -392,7 +396,7 @@ class ARPackage(Identifiable, CollectableElement):
 
     def getSwComponentTypes(self) -> List[SwComponentType]:
         return list(filter(lambda a : isinstance(a, SwComponentType), self.elements.values()))
-    
+
     def getSensorActuatorSwComponentType(self) -> List[SensorActuatorSwComponentType]:
         return list(filter(lambda a : isinstance(a, SensorActuatorSwComponentType), self.elements.values()))
 
@@ -401,13 +405,13 @@ 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(sorted(filter(lambda a : isinstance(a, SenderReceiverInterface), self.elements.values()), key = lambda a: a.short_name))
-    
+
     def getParameterInterfaces(self) -> List[ParameterInterface]:
         return list(sorted(filter(lambda a : isinstance(a, ParameterInterface), self.elements.values()), key = lambda a: a.short_name))
 
@@ -416,7 +420,7 @@ class ARPackage(Identifiable, CollectableElement):
 
     def getDataTypeMappingSets(self) -> List[DataTypeMappingSet]:
         return list(sorted(filter(lambda a : isinstance(a, DataTypeMappingSet), self.elements.values()), key = lambda a: a.short_name))
-    
+
     def getCompuMethods(self) -> List[CompuMethod]:
         return list(filter(lambda a: isinstance(a, CompuMethod), self.elements.values()))
 
@@ -428,214 +432,105 @@ class ARPackage(Identifiable, CollectableElement):
 
     def getBswImplementations(self) -> List[BswImplementation]:
         return list(filter(lambda a: isinstance(a, BswImplementation), self.elements.values()))
-    
+
     def getSwcImplementations(self) -> List[SwcImplementation]:
         return list(filter(lambda a: isinstance(a, SwcImplementation), self.elements.values()))
-    
+
     def getImplementations(self) -> List[Implementation]:
         return list(filter(lambda a: isinstance(a, Implementation), self.elements.values()))
 
     def getSwcBswMappings(self) -> List[SwcBswMapping]:
         return list(filter(lambda a: isinstance(a, SwcBswMapping), self.elements.values()))
-    
+
     def getConstantSpecifications(self) -> List[ConstantSpecification]:
         return list(filter(lambda a: isinstance(a, ConstantSpecification), self.elements.values()))
-    
+
     def getDataConstrs(self) -> List[DataConstr]:
         return list(filter(lambda a: isinstance(a, DataConstr), self.elements.values()))
-    
+
     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))
 
     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 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))
-    
+
     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 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))
-    
+
     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 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 AbstractAUTOSAR(CollectableElement):
-    def __init__(self):
-        super().__init__()
-
-        CollectableElement.__init__(self)
-
-        self.schema_location = ""
-        self._appl_impl_type_maps = {}
-        self._impl_appl_type_maps = {}
-        
-
-        self._ar_packages = {}                  # type: Dict[str, ARPackage]
-        self.short_name_mappings = {}           # type: Dict[str, str]
-
-    def reload(self):
-        pass
-
-    @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(sorted(self._ar_packages.values(), key= lambda a: a.short_name))
-
-    def createARPackage(self, short_name: str) -> ARPackage:
-        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 find(self, referred_name: str) -> Referrable:
-        short_name_list = referred_name.split("/")
-        element = AUTOSAR.getInstance()
-        for short_name in short_name_list:
-            if (short_name == ""):
-                continue
-            element = element.getElement(short_name)
-            if (element == None):
-                return element
-            #    raise ValueError("The %s of reference <%s> does not exist." % (short_name, referred_name))
-        return element
-    
-    def findByShortName(self, short_name: str) -> Referrable:
-        pass
-
-    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.swDataDefProps.implementationDataTypeRef.value)
-                return self.getDataType(referred_type)
-            if (data_type.category == ImplementationDataType.CATEGORY_DATA_REFERENCE):
-                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:
-            raise ValueError("%s is not ImplementationDataType." % data_type)
-            
-    def addDataTypeMap(self, data_type_map: DataTypeMap):
-        if (data_type_map.application_data_type_ref is None) or (data_type_map.implementation_data_type_ref is None):
-            return
-        self._appl_impl_type_maps[data_type_map.application_data_type_ref.value] = data_type_map.implementation_data_type_ref.value
-        self._impl_appl_type_maps[data_type_map.implementation_data_type_ref.value] = data_type_map.application_data_type_ref.value
-
-    def convertToImplementationDataType(self, appl_data_type: str) -> ImplementationDataType:
-        if (appl_data_type not in self._appl_impl_type_maps.keys()):
-            raise IndexError("Invalid application data type <%s>" % appl_data_type)
-
-        return self.find(self._appl_impl_type_maps[appl_data_type])
-
-    def convertToApplicationDataType(self, impl_data_type: str) -> ApplicationDataType:
-        if (impl_data_type not in self._impl_appl_type_maps.keys()):
-            raise IndexError("Invalid Implementation data type <%s>" % impl_data_type)
-        
-        return self.find(self._impl_appl_type_maps[impl_data_type])
-
-    
-class AUTOSAR (AbstractAUTOSAR):        
-    __instance = None
-
-    @staticmethod
-    def getInstance():
-        if (AUTOSAR.__instance == None):
-            AUTOSAR()
-        return AUTOSAR.__instance
-
-    def __init__(self):
-        if (AUTOSAR.__instance != None):
-            raise Exception("The AUTOSAR is singleton!")
-        
-        AUTOSAR.__instance = self
-
-        super().__init__()
-
-class AUTOSARDoc(AbstractAUTOSAR):
-    def __init__(self):
-        super().__init__()
-        

armodel/models/M2/AUTOSARTemplates/GenericStructure/GeneralTemplateClasses/ArObject.py

@@ -0,0 +1,16 @@
+from abc import ABCMeta
+from typing import Dict
+
+class ARObject(metaclass = ABCMeta):
+    def __init__(self):
+        if type(self) == ARObject:
+            raise NotImplementedError("ARObject is an abstract class.")
+
+        self.parent = None              # type: ARObject
+        self.checksum = None            # type: str
+
+        self.timestamp = None           # type: str
+        self.uuid = None                # type: str
+
+    def getTagName(self, tag: str, nsmap: Dict) -> str:
+        return tag.replace("{%s}" % nsmap["xmlns"], "")

armodel/models/M2/AUTOSARTemplates/GenericStructure/GeneralTemplateClasses/ElementCollection.py

@@ -0,0 +1 @@
+