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

armodel/models/M2/AUTOSARTemplates/CommonStructure/Implementation.py

@@ -0,0 +1,81 @@
+from abc import ABCMeta
+from typing import List
+from .ResourceConsumption import ResourceConsumption
+from ..GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, PackageableElement, Referrable
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, RefType, ARLiteral
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+
+class ImplementationProps(Referrable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == ImplementationProps:
+            raise NotImplementedError("ImplementationProps is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        self.symbol = None                          # type: ARLiteral
+
+    def getSymbol(self):
+        return self.symbol
+
+    def setSymbol(self, value):
+        self.symbol = value
+        return self
+
+
+class Code(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._artifactDescriptors = []          # type: List[AutosarEngineeringObject]
+        self.callbackHeaderRefs = []            # type: List[RefType]
+
+    def addArtifactDescriptor(self, desc: AutosarEngineeringObject):
+        self._artifactDescriptors.append(desc)
+
+    def getArtifactDescriptors(self, category:str = "") -> List[AutosarEngineeringObject]:
+        if (category == ""):
+            return self._artifactDescriptors
+        else:
+            return list(filter(lambda a: a.getCategory().getText() == category, self._artifactDescriptors))
+
+
+class Implementation(PackageableElement, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str) -> None:
+        if type(self) == Implementation:
+            raise NotImplementedError("Implementation is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+        self.build_action_manifest_ref = None               # type: RefType
+        self.compilers = None
+        self.generated_artifacts = None
+        self.hw_element_refs = []                           # type: List[RefType]
+        self.linker = []
+        self.mc_support = None
+        self.programming_language = None                    # type: ARLiteral
+        self.required_artifacts = []
+        self.required_generator_tools = []
+        self.resource_consumption = None                    # type: ResourceConsumption
+        self.sw_version = ""                                # type: ARLiteral
+        self.swc_bsw_mapping_ref = None                     # type: RefType
+        self.used_code_generator = None                     # type: ARLiteral
+        self.vendor_id = 0                                  # type: ARNumerical
+
+    def createCodeDescriptor(self, short_name: str) -> Code:
+        if (short_name not in self.elements):
+            sw_component = Code(self, short_name)
+            self.elements[short_name] = sw_component
+        return self.elements[short_name]
+
+    def getCodeDescriptors(self)-> List[Code]:
+        return list(filter(lambda a : isinstance(a, Code), self.elements.values()))
+
+    def setResourceConsumption(self, consumption: ResourceConsumption):
+        self.elements[consumption.short_name] = consumption
+        self.resource_consumption = consumption
+        return self
+
+    def getResourceConsumption(self) -> ResourceConsumption:
+        return self.resource_consumption

armodel/models/{m2/autosar_templates/common_structure/implementation_data_types.py → M2/AUTOSARTemplates/CommonStructure/ImplementationDataTypes.py}

@@ -1,11 +1,15 @@
 from abc import ABCMeta
 from typing import List
 
-from ...msr.data_dictionary.data_def_properties import SwDataDefProps
-from ....general_structure import Identifiable
-from ....ar_object import ARBoolean, ARLiteral, ARNumerical, ARObject
-from ....datatype import AutosarDataType
-from ..sw_component_template.components import SymbolProps
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical
+
+from ...MSR.DataDictionary.DataDefProperties import SwDataDefProps
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean
+from ..SWComponentTemplate.Datatype.Datatypes import AutosarDataType
+from ..SWComponentTemplate.Components import SymbolProps
 
 class AbstractImplementationDataTypeElement(Identifiable):
     def __init__(self, parent, short_name: str):

armodel/models/M2/AUTOSARTemplates/CommonStructure/InternalBehavior.py

@@ -0,0 +1,108 @@
+from abc import ABCMeta
+from enum import Enum
+from typing import List
+
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, RefType
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype
+
+class ReentrancyLevelEnum(Enum):
+
+    multicoreReentrant = "multicoreReentrant"
+    nonReentrant = "nonReentrant"
+    singleCoreReentrant = "singleCoreReentrant"
+
+
+class ExclusiveArea(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+
+class ExecutableEntity(Identifiable, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == ExecutableEntity:
+            raise NotImplementedError("ExecutableEntity is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+        self.activationReason = None                # *
+        self.minimumStartInterval = None            # type: ARFloat
+        self.reentrancyLevel = None                 # 
+        self.canEnterExclusiveAreaRefs = []         # type: List[RefType]  
+        self.swAddrMethodRef = None                 # type: RefType
+
+    def getActivationReason(self):
+        return self.activationReason
+
+    def setActivationReason(self, value):
+        self.activationReason = value
+        return self
+
+    def getMinimumStartInterval(self):
+        return self.minimumStartInterval
+
+    def setMinimumStartInterval(self, value):
+        self.minimumStartInterval = value
+        return self
+
+    def getReentrancyLevel(self):
+        return self.reentrancyLevel
+
+    def setReentrancyLevel(self, value):
+        self.reentrancyLevel = value
+        return self
+
+    def getSwAddrMethodRef(self):
+        return self.swAddrMethodRef
+
+    def setSwAddrMethodRef(self, value):
+        self.swAddrMethodRef = value
+        return self
+
+    @property
+    def minimumStartIntervalMs(self) -> int:
+        if self.minimumStartInterval is not None:
+            return int(self.minimumStartInterval.getValue() * 1000)
+        return None
+
+    def addCanEnterExclusiveAreaRef(self, ref: RefType):
+        self.canEnterExclusiveAreaRefs.append(ref)
+
+    def getCanEnterExclusiveAreaRefs(self):
+        return self.canEnterExclusiveAreaRefs
+
+
+class InternalBehavior(Identifiable, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == InternalBehavior:
+            raise NotImplementedError("InternalBehavior is an abstract class.")
+        super().__init__(parent, short_name)
+
+        self.data_type_mapping_refs = []        # type: List[RefType]                       
+        self.constant_memories = []             # type: List[ParameterDataPrototype]
+
+    def addDataTypeMappingRef(self, ref: RefType):
+        self.data_type_mapping_refs.append(ref)
+
+    def getDataTypeMappingRefs(self) -> List[RefType]:
+        return self.data_type_mapping_refs
+
+    def createExclusiveArea(self, short_name: str) -> ExclusiveArea:
+        if (short_name not in self.elements):
+            event = ExclusiveArea(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def getExclusiveAreas(self) -> List[ExclusiveArea]:
+        return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements.values()))
+
+    def createConstantMemory(self, short_name: str) -> ParameterDataPrototype:
+        if (short_name not in self.elements):
+            prototype = ParameterDataPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self.constant_memories.append(prototype)
+        return self.elements[short_name]
+
+    def getConstantMemorys(self) -> List[ParameterDataPrototype]:
+        return self.constant_memories

armodel/models/M2/AUTOSARTemplates/CommonStructure/ModeDeclaration.py

@@ -0,0 +1,96 @@
+from typing import List
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical, RefType, TRefType
+
+class ModeDeclaration(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.value = None                           # type: ARNumerical
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
+    def getValue(self) -> ARNumerical:
+        return self.value
+
+
+class ModeRequestTypeMap(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.implementation_data_type_ref = None           # type: RefType
+        self.mode_group_ref = None                        # type: RefType
+
+
+class ModeDeclarationGroup(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._initial_mode_ref = None                      # type: RefType
+        self._on_transition_value = None                   # type: ARNumerical
+
+    def createModeDeclaration(self, short_name: str) -> ModeDeclaration:
+        if (short_name not in self.elements):
+            spec = ModeDeclaration(self, short_name)
+            self.elements[short_name] = spec
+        return self.elements[short_name]
+
+    def getModeDeclarations(self) -> List[ModeDeclaration]:
+        return list(sorted(filter(lambda a: isinstance(a, ModeDeclaration), self.elements.values()), key= lambda o:o.short_name))
+
+    def setInitialModeRef(self, ref: RefType):
+        self._initial_mode_ref = ref
+        return self
+
+    def getInitialModeRef(self) -> RefType:
+        return self._initial_mode_ref
+
+    def setOnTransitionValue(self, value):
+        if isinstance(value, int):
+            value = ARNumerical()
+            value.setValue(value)
+        self._on_transition_value = value
+        return self
+
+    def getOnTransitionValue(self) -> ARNumerical:
+        return self._on_transition_value
+
+
+class ModeDeclarationGroupPrototype(Identifiable):
+
+    """
+    The ModeDeclarationGroupPrototype specifies a set of Modes (ModeDeclarationGroup) which is provided or required in the given context.
+    """
+
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._swCalibrationAccess = None        # type: str
+        self.typeTRef = None                    # type: TRefType
+
+    @property
+    def sw_calibration_access(self):
+        return self._swCalibrationAccess
+
+    @sw_calibration_access.setter
+    def sw_calibration_access(self, value):
+        if (value not in ("notAccessible", "readOnly", "readWrite")):
+            raise ValueError("Invalid SwCalibrationAccess <%s> of ModeDeclarationGroupPrototype <%s>" % (value, self.short_name))
+        self._swCalibrationAccess = value
+
+    def getSwCalibrationAccess(self):
+        return self.swCalibrationAccess
+
+    def setSwCalibrationAccess(self, value):
+        self.swCalibrationAccess = value
+        return self
+
+    def getTypeTRef(self):
+        return self.typeTRef
+
+    def setTypeTRef(self, value):
+        self.typeTRef = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/MemorySectionUsage.py

@@ -0,0 +1,72 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType
+
+
+import re
+from typing import List
+
+
+class MemorySection(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._alignment = None              # type: ARLiteral
+        self.size = None
+        self.options = []                   # type: List[ARLiteral]
+        self.swAddrMethodRef = None         # type: RefType
+        self.symbol = None                  # type: ARLiteral
+
+    def getAlignment(self):
+        return self.alignment
+
+    def setAlignment(self, value):
+        self.alignment = value
+        return self
+
+    def getSize(self):
+        return self.size
+
+    def setSize(self, value):
+        self.size = value
+        return self
+
+    def getSwAddrMethodRef(self):
+        return self.swAddrMethodRef
+
+    def setSwAddrMethodRef(self, value):
+        self.swAddrMethodRef = value
+        return self
+
+    def getSymbol(self):
+        return self.symbol
+
+    def setSymbol(self, value):
+        self.symbol = value
+        return self
+
+    @property
+    def alignment(self) -> ARLiteral:
+        return self._alignment
+
+    @alignment.setter
+    def alignment(self, value: ARLiteral):
+        if value is not None and value.getValue() != "":
+            match = False
+            if value.getValue() in ("UNKNOWN", "UNSPECIFIED", "BOOLEAN", "PTR"):
+                self._alignment = value
+                match = True
+            else:
+                m = re.match(r'^\d+', value.value)
+                if m:
+                    self._alignment = value
+                    match = True
+
+            if not match:
+                raise ValueError("Invalid alignment <%s> of memory section <%s>" % (value, self.getShortName()))
+
+    def addOption(self, option: ARLiteral):
+        self.options.append(option)
+
+    def getOptions(self) -> List[ARLiteral]:
+        return self.options

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/__init__.py

@@ -0,0 +1,22 @@
+from . import *
+
+from .MemorySectionUsage import MemorySection
+from ...GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ...GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from typing import List
+
+class ResourceConsumption(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+    def createMemorySection(self, short_name: str) -> MemorySection:
+        if (short_name not in self.elements):
+            entry = MemorySection(self, short_name)
+            self.elements[short_name] = entry
+        return self.elements[short_name]
+
+    def getMemorySections(self) -> List[MemorySection]:
+        return list(filter(lambda a : isinstance(a, MemorySection), self.elements.values()))
+
+    def getMemorySection(self, short_name: str) -> MemorySection:
+        return next(filter(lambda o: isinstance(o, MemorySection) and (o.short_name == short_name), self.elements.values()), None)

armodel/models/{service_needs.py → M2/AUTOSARTemplates/CommonStructure/ServiceNeeds.py}

@@ -1,10 +1,8 @@
-
 from abc import ABCMeta
-
-from .m2.autosar_templates.sw_component_template.swc_internal_behavior.instance_refs_usage import AutosarParameterRef, AutosarVariableRef
-from .general_structure import Identifiable
-from .ar_ref import RefType
-from .ar_object import ARBoolean, ARLiteral, ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean, ARLiteral, RefType
+from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, AutosarVariableRef
 
 
 class RoleBasedDataAssignment(ARObject):
@@ -16,13 +14,15 @@ class RoleBasedDataAssignment(ARObject):
         self.used_parameter_element = None  # type: AutosarParameterRef
         self.used_pim_ref = None            # type: RefType
 
+
 class ServiceNeeds(Identifiable, metaclass = ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == ServiceNeeds:
             raise NotImplementedError("ServiceNeeds is an abstract class.")
-        
+
         super().__init__(parent, short_name)
 
+
 class NvBlockNeeds(ServiceNeeds):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)

armodel/models/M2/AUTOSARTemplates/CommonStructure/SwcBswMapping.py

@@ -0,0 +1,36 @@
+from typing import List
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+
+
+class SwcBswRunnableMapping(ARObject):
+    def __init__(self):
+        '''
+            Maps a BswModuleEntity to a RunnableEntity if it is implemented as part of a BSW
+            module (in the case of an AUTOSAR Service, a Complex Driver or an ECU
+            Abstraction). The mapping can be used by a tool to find relevant information on the
+            behavior, e.g. whether the bswEntity shall be running in interrupt context.
+
+        '''
+        super().__init__()
+
+        self.bswEntityRef   = None        # type: RefType
+        self.swcRunnableRef = None        # type: RefType
+
+
+class SwcBswMapping(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.bswBehaviorRef = None              # type: RefType
+        self._runnableMappings = []
+        self.swcBehaviorRef = None              # type: RefType
+        self.synchronizedModeGroups = []
+        self.synchronizedTriggers = []
+
+    def addRunnableMapping(self, mapping: SwcBswRunnableMapping):
+        self._runnableMappings.append(mapping)
+
+    def getRunnableMappings(self) -> List[SwcBswRunnableMapping]:
+        return self._runnableMappings

armodel/models/M2/AUTOSARTemplates/CommonStructure/SwcInternalBehavior/ModeDeclarationGroup.py

@@ -0,0 +1,27 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType
+
+
+from typing import List
+
+
+class IncludedModeDeclarationGroupSet(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.mode_declaration_group_refs = []           # type: List[RefType]
+        self.prefix = None                              # type: ARLiteral
+
+    def addModeDeclarationGroupRef(self, ref: RefType):
+        self.mode_declaration_group_refs.append(ref)
+        return self
+
+    def getModeDeclarationGroupRefs(self) -> List[RefType]:
+        return self.mode_declaration_group_refs
+
+    def setPrefix(self, prefix: str):
+        self.prefix = prefix
+        return self
+
+    def getPrefix(self) -> ARLiteral:
+        return self.prefix

armodel/models/M2/AUTOSARTemplates/CommonStructure/SwcInternalBehavior/__init__.py

@@ -0,0 +1 @@
+from . import *

armodel/models/M2/AUTOSARTemplates/CommonStructure/TriggerDeclaration.py

@@ -0,0 +1,9 @@
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ..GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+
+class Trigger(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.swImplPolicy = None    # type: str
+        self.triggerPeriod = None   # type: float

armodel/models/{m2/autosar_templates/common_structure → M2/AUTOSARTemplates/CommonStructure}/__init__.py

@@ -1,8 +1,11 @@
 from abc import ABCMeta
 from typing import List
 
-from armodel.models.general_structure import ARElement
-from ....ar_object import ARLiteral, ARNumerical, ARObject
+from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARNumerical
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement
+from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral
 
 class ValueSpecification(ARObject, metaclass = ABCMeta):
     '''

armodel/models/{m2/autosar_templates/generic_structure/abstract_structure.py → M2/AUTOSARTemplates/GenericStructure/AbstractStructure.py}

@@ -2,9 +2,10 @@
 from abc import ABCMeta
 from typing import List
 
-from ....ar_ref import RefType
-from ....ar_object import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable
 
+from .GeneralTemplateClasses.PrimitiveTypes import RefType
+from .GeneralTemplateClasses.ArObject import ARObject
 
 class AtpInstanceRef(ARObject, metaclass = ABCMeta):
     def __init__(self):
@@ -67,3 +68,25 @@ class AnyInstanceRef(ARObject):
     def setTargetRef(self, value:RefType):
         self.targetRef = value
         return self
+
+
+class AtpFeature(Identifiable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AtpFeature:
+            raise NotImplementedError("AtpFeature is an abstract class.")
+        super().__init__(parent, short_name)
+
+
+class AtpStructureElement(AtpFeature, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AtpFeature:
+            raise NotImplementedError("AtpStructureElement is an abstract class.")
+        super().__init__(parent, short_name)
+
+
+class AtpType(ARElement, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AtpType:
+            raise NotImplementedError("AtpType is an abstract class.")
+
+        super().__init__(parent, short_name)

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

@@ -1,28 +1,36 @@
-from armodel.models.bsw_module_template import BswModuleDescription, BswModuleEntry
-from armodel.models.common_structure import ModeDeclarationGroup
-from armodel.models.datatype import ApplicationArrayDataType, ApplicationDataType, ApplicationPrimitiveDataType, ApplicationRecordDataType, DataTypeMappingSet, SwBaseType
-from armodel.models.end_to_end_protection import EndToEndProtectionSet
+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.general_structure import ARObject, CollectableElement, Identifiable, Referrable, SwcBswMapping
-from armodel.models.global_constraints import DataConstr
-from armodel.models.implementation import BswImplementation, Implementation, SwcImplementation
-from armodel.models.m2.autosar_templates.common_structure import ConstantSpecification
-from armodel.models.m2.autosar_templates.common_structure.implementation_data_types import ImplementationDataType
-from armodel.models.m2.autosar_templates.ecuc_description_template import EcucModuleConfigurationValues, EcucValueCollection
-from armodel.models.m2.autosar_templates.sw_component_template.components import SwComponentType
-from armodel.models.m2.autosar_templates.sw_component_template.composition import CompositionSwComponentType
-from armodel.models.m2.autosar_templates.sw_component_template.port_interface import ClientServerInterface, ModeSwitchInterface, ParameterInterface, SenderReceiverInterface, TriggerInterface
-from armodel.models.m2.autosar_templates.system_template import System
-from armodel.models.m2.autosar_templates.system_template.network_management import NmConfig
-from armodel.models.m2.autosar_templates.system_template.transport_protocols import CanTpConfig
-from armodel.models.m2.msr.asam_hdo.units import PhysicalDimension, Unit
-from armodel.models.m2.msr.data_dictionary.auxillary_objects import SwAddrMethod
-from armodel.models.m2_msr import CompuMethod
-from armodel.models.record_layout import SwRecordLayout
+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
 
@@ -525,4 +533,4 @@ class ARPackage(Identifiable, CollectableElement):
         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))
+        return list(sorted(filter(lambda a : isinstance(a, System), self.elements.values()), key = lambda a: a.short_name))

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 @@
+