armodel 1.3.0__py3-none-any.whl → 1.4.3__py3-none-any.whl

armodel/models/datatype.py

@@ -1,10 +1,13 @@
 from abc import ABCMeta
 from typing import List
-from .general_structure import ARElement, Referrable, ARObject
-from .data_prototype import ApplicationArrayElement, ApplicationRecordElement
-from .data_dictionary import SwDataDefProps
-from .common_structure import ImplementationDataTypeElement
 
+from .ar_object import ARLiteral, ARNumerical
+from .ar_ref import RefType
+from .ar_package import Referrable
+from .general_structure import ARElement, ARObject, Identifiable
+from .data_prototype import ApplicationCompositeElementDataPrototype, ApplicationRecordElement
+from .data_dictionary import SwDataDefProps
+from .common_structure import ImplementationDataTypeElement, ModeRequestTypeMap
 
 class ImplementationProps(Referrable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -14,11 +17,23 @@ class ImplementationProps(Referrable, metaclass=ABCMeta):
         super().__init__(parent, short_name)
         self.symbol = ""
 
-
 class SymbolProps(ImplementationProps):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+class BaseTypeDefinition(ARObject):
+    def __init__(self):
+        super().__init__()
+    
+class BaseTypeDirectDefinition(BaseTypeDefinition):
+    def __init__(self):
+        super().__init__()
+
+        self.base_type_encoding = None
+        self.base_type_size = None                # type: ARNumerical
+        self.byteOrder = None                   # type: str
+        self.mem_alignment = None                # type: ARNumerical
+        self.native_declaration = None      
 
 class BaseType(ARElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -26,14 +41,13 @@ class BaseType(ARElement, metaclass=ABCMeta):
             raise NotImplementedError("BaseType is an abstract class.")
 
         super().__init__(parent, short_name)
-        self.base_type_definition = None  # Type: BaseTypeDefinition
 
+        self.baseTypeDefinition = BaseTypeDirectDefinition()
 
 class SwBaseType(BaseType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-
 class AtpType(ARElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == AtpType:
@@ -71,25 +85,60 @@ class ApplicationCompositeDataType(ApplicationDataType, metaclass=ABCMeta):
 
         super().__init__(parent, short_name)
 
+class ApplicationArrayElement(ApplicationCompositeElementDataPrototype):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.arraySizeHandling = None               # type: str
+        self.arraySizeSemantics = None              # type: str
+        self.indexDataTypeRef = None                # type: RefType
+        self.maxNumberOfElements = None             # type: ARNumerical
+
+    def setArraySizeHandling(self, handling: str):
+        self.arraySizeHandling = handling
+        return self
+    
+    def setArraySizeSemantics(self, semantics: str):
+        self.arraySizeSemantics = semantics
+        return self
+    
+    def setIndexDataTypeRef(self, ref: RefType):
+        self.indexDataTypeRef = ref
+        return self
+    
+    def setMaxNumberOfElements(self, number: ARNumerical):
+        self.maxNumberOfElements = number
+        return self
 
 class ApplicationArrayDataType(ApplicationCompositeDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.dynamic_array_size_profile = ""
-        self.element = None
-
+        self.dynamic_array_size_profile = None      # type: ARLiteral
+        self.element = None                         # type: ApplicationArrayElement
 
+    def createApplicationArrayElement(self, short_name: str) -> ApplicationArrayElement:
+        if (short_name not in self.elements):
+            array_element = ApplicationArrayElement(self, short_name)
+            self.elements[short_name] = array_element
+            self.element = self.elements[short_name]
+        return self.elements[short_name]
+    
 class ApplicationRecordDataType(ApplicationCompositeDataType):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
+        self.record_elements = []
+
     def createApplicationRecordElement(self, short_name: str) -> ApplicationRecordElement:
         if (short_name not in self.elements):
             record_element = ApplicationRecordElement(self, short_name)
             self.elements[short_name] = record_element
+            self.record_elements.append(self.elements[short_name])
         return self.elements[short_name]
 
+    def getApplicationRecordElements(self) -> List[ApplicationRecordElement]:
+        return self.record_elements
 
 class AbstractImplementationDataType(AutosarDataType, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -108,9 +157,10 @@ class ImplementationDataType(AbstractImplementationDataType):
 
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
-        self.sub_elements = []      # List(str)
-        self.symbol_props = None    # SymbolProps
-        self.type_emitter = None
+        
+        self.sub_elements = []      # type: List[str]
+        self.symbol_props = None    # type: ARLiteral
+        self._type_emitter = None    # type: ARLiteral
 
         self._array_type = None     # ImplementationDataType
 
@@ -134,21 +184,38 @@ class ImplementationDataType(AbstractImplementationDataType):
 
     def setArrayElementType(self, type: str):
         self._array_type = type
+        return self
+
+    def setTypeEmitter(self, emitter: str):
+        self._type_emitter = emitter
+        return self
+    
+    def getTypeEmitter(self) -> str:
+        return self._type_emitter
 
 
 class DataTypeMap(ARObject):
     def __init__(self):
-        self.application_data_type_ref = None  # type: RefType
-        self.implementation_data_type_ref = None  # type: RefType
-
+        self.application_data_type_ref = None       # type: RefType
+        self.implementation_data_type_ref = None    # type: RefType
 
 class DataTypeMappingSet(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
-        self.data_type_maps = []  # type: List[DataTypeMap]
+        
+        self._dataTypeMaps = []                     # type: List[DataTypeMap]
+        self._modeRequestTypeMaps = []              # type: List[ModeRequestTypeMap]
 
     def addDataTypeMap(self, type_map: DataTypeMap):
-        self.data_type_maps.append(type_map)
+        self._dataTypeMaps.append(type_map)
 
     def getDataTypeMaps(self) -> List[DataTypeMap]:
-        return self.data_type_maps
+        return self._dataTypeMaps
+    
+    def addModeRequestTypeMap(self, map: ModeRequestTypeMap):
+        self._modeRequestTypeMaps.append(map)
+
+    def getModeRequestTypeMaps(self) -> List[ModeRequestTypeMap]:
+        return self._modeRequestTypeMaps
+    
+

armodel/models/end_to_end_protection.py

@@ -0,0 +1,67 @@
+from typing import List
+
+from .ar_ref import VariableDataPrototypeInSystemInstanceRef
+from .ar_object import ARNumerical, ARObject
+from .general_structure import Identifiable
+
+
+class EndToEndDescription(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.category = None                # type: str
+        self.counterOffset = None           # type: int
+        self.crcOffset = None               # type: int
+        self.dataIds = []                   # type: List[ARNumerical]
+        self.dataIdMode = None              # type: int
+        self.dataIdNibbleOffset = None      # type: int
+        self.dataLength = None              # type: int
+        self.maxDeltaCounterInit = None     # type: int
+        self.maxNoNewOrRepeatedData = None  # type: int
+        self.syncCounterInit = None         # type: int
+
+    def addDataId(self, id: ARNumerical):
+        self.dataIds.append(id)
+    
+    def getDataIds(self) -> List[ARNumerical]:
+        return sorted(self.dataIds, key = lambda a: a) 
+
+class EndToEndProtectionVariablePrototype(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._receiverIRefs = []            # type: List[VariableDataPrototypeInSystemInstanceRef]
+        self.senderIRef = None             # type: VariableDataPrototypeInSystemInstanceRef
+        self.shortLabel = None              # type: str
+
+    def addReceiverIref(self, iref: VariableDataPrototypeInSystemInstanceRef):
+        self._receiverIRefs.append(iref)
+
+    def getReceiverIrefs(self) -> List[VariableDataPrototypeInSystemInstanceRef]:
+        return self._receiverIRefs
+
+class EndToEndProtection(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.endToEndProfile = None                         # type: EndToEndDescription
+        self.endToEndProtectionVariablePrototype = []       # type: List[EndToEndProtectionVariablePrototype]
+
+    def addEndToEndProtectionVariablePrototype(self, prototype: EndToEndProtectionVariablePrototype):
+        self.endToEndProtectionVariablePrototype.append(prototype)
+
+    def getEndToEndProtectionVariablePrototypes(self) -> List[EndToEndProtectionVariablePrototype]:
+        return self.endToEndProtectionVariablePrototype
+
+class EndToEndProtectionSet(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+    def createEndToEndProtection(self, short_name: str) -> EndToEndProtection:
+        if (short_name not in self.elements):
+            protection = EndToEndProtection(self, short_name)
+            self.elements[short_name] = protection
+        return self.elements[short_name]
+    
+    def getEndToEndProtections(self) -> List[EndToEndProtection]:
+        return sorted(filter(lambda c: isinstance(c, EndToEndProtection), self.elements.values()), key= lambda e: e.short_name)

armodel/models/general_structure.py

@@ -1,13 +1,53 @@
 from abc import ABCMeta
 from typing import List
-from .ar_object import ARObject
+
 from .ar_ref import RefType
+from .multilanguage_data import MultiLanguageOverviewParagraph, MultilanguageLongName
+from .ar_object import ARObject
+
+class Sd(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.gid = ""
+        self.value = ""
+
+class Sdg(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.gid = ""
+        self.sd = []                        # type: List[Sd]
+        self.sdg_caption = None
+        self.sdg_contents_type = None
 
+    def addSd(self, sd: Sd):
+        self.sd.append(sd)
+
+    def getSds(self) -> List[Sd]:
+        return self.sd
+    
+class AdminData(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.doc_revision = []
+        self.language = None
+        self.sdg = []
+        self.used_languages = None
+
+    def addSdg(self, sdg: Sdg):
+        self.sdg.append(sdg)
+
+    def getSdgs(self) -> List[Sdg]:
+        return self.sdg
 
 class Referrable(ARObject, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == Referrable:
             raise NotImplementedError("Referrable is an abstract class.")
+        ARObject.__init__(self)
+
         self.parent = parent
         self.short_name = short_name
 
@@ -19,15 +59,26 @@ class MultilanguageReferrable(Referrable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == MultilanguageReferrable:
             raise NotImplementedError("MultilanguageReferrable is an abstract class.")
+        
         super().__init__(parent, short_name)
+
         self.parent = parent
-        self.long_name = None
+        self.long_name = None            # type: MultilanguageLongName
 
-class CollectableElement(metaclass=ABCMeta):
+class CollectableElement(ARObject, metaclass=ABCMeta):
     def __init__(self):
         if type(self) == CollectableElement:
             raise NotImplementedError("CollectableElement is an abstract class.")
-        self.elements = {}              # type: dict(PackageableElement)
+        self.elements = {}              # type: dict[str, PackageableElement]
+
+    def getTotalElement(self) -> int:
+        #return len(list(filter(lambda a: not isinstance(a, ARPackage) , self.elements.values())))
+        return len(self.elements.values())
+    
+    def removeElement(self, key):
+        if key not in self.elements:
+            raise KeyError("Invalid key <%s> for removing element" % key)
+        self.elements.pop(key)
 
     def getElements(self):
         return self.elements.values()
@@ -44,8 +95,9 @@ class Identifiable(MultilanguageReferrable, CollectableElement, metaclass=ABCMet
         MultilanguageReferrable.__init__(self, parent, short_name)
         CollectableElement.__init__(self)
 
+        self.admin_data = None      # type: AdminData
         self._category = None
-        self.desc = None
+        self.desc = None            # type: MultiLanguageOverviewParagraph
 
     @property
     def category(self):
@@ -78,30 +130,31 @@ class SwcBswRunnableMapping(ARObject):
         '''
         super().__init__()
 
-        self.bsw_entity_ref   = None        # type: RefType
-        self.swc_runnable_ref = None        # type: RefType
+        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.bsw_behavior_ref = None            # type: RefType
-        self.runnable_mappings = []
-        self.swc_behavior_ref = None            # type: RefType
-        self.synchronized_mode_groups = []       
-        self.synchronized_triggers = []
+        self.bswBehaviorRef = None              # type: RefType
+        self._runnableMappings = []
+        self.swcBehaviorRef = None              # type: RefType
+        self.synchronizedModeGroups = []       
+        self.synchronizedTriggers = []
 
     def addRunnableMapping(self, mapping: SwcBswRunnableMapping):
-        self.runnable_mappings.append(mapping)
+        self._runnableMappings.append(mapping)
 
     def getRunnableMappings(self) -> List[SwcBswRunnableMapping]:
-        return self.runnable_mappings
+        return self._runnableMappings
 
 class ARElement(PackageableElement, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
         if type(self) == ARElement:
             raise NotImplementedError("ARElement is an abstract class.")
         super().__init__(parent, short_name)
+        
 
 class AtpStructureElement(AtpFeature, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -109,7 +162,9 @@ class AtpStructureElement(AtpFeature, metaclass=ABCMeta):
             raise NotImplementedError("AtpStructureElement is an abstract class.")
         super().__init__(parent, short_name)
 
-class Limit:
+class Limit(ARObject):
     def __init__(self):
-        self.interval_type = None
-        self.value = None
+        super().__init__()
+
+        self.intervalType = None       # type: str
+        self.value = None               # type: str

armodel/models/global_constraints.py

@@ -0,0 +1,40 @@
+from .ar_ref import RefType
+from .ar_object import ARNumerical, ARObject
+from .general_structure import Identifiable, Limit
+
+from typing import List
+
+class InternalConstrs(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.lower_limit = None         # type: Limit
+        self.upper_limit = None         # type: Limit
+
+class PhysConstrs(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.lower_limit = None         # type: Limit
+        self.upper_limit = None         # type: Limit
+        self.unit_ref = None            # type: RefType
+
+class DataConstrRule(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.constrLevel = None         # type: ARNumerical
+        self.internalConstrs = None     # type: InternalConstrs    
+        self.physConstrs = None         # type: PhysConstrs
+
+class DataConstr(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.data_constr_rule = []    #  type: List[DataConstrRule]
+
+    def addDataConstrRule(self, rule: DataConstrRule):
+        self.data_constr_rule.append(rule)
+
+    def getDataConstrRules(self) -> List[DataConstrRule]:
+        return self.data_constr_rule

armodel/models/implementation.py

@@ -1,6 +1,6 @@
 from abc import ABCMeta
 from typing import List
-from .ar_object import ARObject
+from .ar_object import ARLiteral, ARNumerical, ARObject
 from .general_structure import PackageableElement, Identifiable
 from .common_structure import ResourceConsumption
 from .ar_ref import RefType
@@ -12,10 +12,43 @@ class EngineeringObject(ARObject, metaclass=ABCMeta):
 
         super().__init__()
 
-        self.category = ""
-        self.domain = None                  # type: str
-        self.revision_label = None          # type: str
-        self.short_label = ""               # type: str
+        self.category = None                # type: ARLiteral
+        self.domain = None                  # type: ARLiteral
+        self.revision_label = None           # type: ARLiteral
+        self.short_label = None              # type: ARLiteral
+
+    def setCategory(self, category: ARLiteral):
+        if isinstance(category, ARLiteral):
+            self.category = category
+        else:
+            self.category = ARLiteral()
+            self.category.setValue(str(category))
+            
+        return self
+    
+    def getCategory(self) -> ARLiteral:
+        return self.category
+    
+    def setDomain(self, domain: ARLiteral):
+        self.domain = domain
+        return self
+    
+    def getDomain(self) -> ARLiteral:
+        return self.domain
+    
+    def setRevisionLabel(self, revision_label: ARLiteral):
+        self.revision_label = revision_label
+        return self
+    
+    def getRevisionLabel(self) -> ARLiteral:
+        return self.revision_label
+    
+    def setShortLabel(self, label: ARLiteral):
+        self.short_label = label
+        return self
+    
+    def getShortLabel(self) -> ARLiteral:
+        return self.short_label
 
 class AutosarEngineeringObject(EngineeringObject):
     def __init__(self):
@@ -25,17 +58,17 @@ class Code(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.artifact_descriptors = []          # type: List[AutosarEngineeringObject]
-        self.callback_header_refs = []          # type: List[RefType]
+        self._artifactDescriptors = []          # type: List[AutosarEngineeringObject]
+        self.callbackHeaderRefs = []            # type: List[RefType]
 
     def addArtifactDescriptor(self, desc: AutosarEngineeringObject):
-        self.artifact_descriptors.append(desc)
+        self._artifactDescriptors.append(desc)
 
     def getArtifactDescriptors(self, category:str = "") -> List[AutosarEngineeringObject]:
         if (category == ""):
-            return self.artifact_descriptors
+            return self._artifactDescriptors
         else:
-            return list(filter(lambda a: a.category == category, self.artifact_descriptors))
+            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:
@@ -43,20 +76,21 @@ class Implementation(PackageableElement, metaclass=ABCMeta):
             raise NotImplementedError("Implementation is an abstract class.")
 
         super().__init__(parent, short_name)
-        self.build_action_manifest = None       # 0..1   
-        self.compiler = None                    # *
-        self.generated_artifact = None          # *
-        self.hw_element = None                  # *
-        self.linker = None                      # *
-        self.mc_support = None                   # 0..1
-        self.programming_language = ""          # 1
-        self.required_artifact = None           # *
-        self.required_generator_tool = None     # *
-        self.resource_consumption = None        # type: ResourceConsumption
-        self.sw_version = ""                    # 1
-        self.swc_bsw_mapping_ref = None         # type: RefType
-        self.used_code_generator = ""           # 0..1
-        self.vendor_id = 0                      # 1
+
+        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):
@@ -67,22 +101,36 @@ class Implementation(PackageableElement, metaclass=ABCMeta):
     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
+
 class BswImplementation(Implementation):
     def __init__(self, parent: ARObject, short_name: str) -> None:
         super().__init__(parent, short_name)
 
-        self.ar_release_version = ""
-        self.revision_label_string = ""                 # 1
-        self.behavior_ref = None                        # type: RefType
-        self.preconfigured_configuration_ref = None     # *
-        self.recommended_configuration_ref = None       # *
-        self.vendor_api_infix = ""                      # 0..1
-        self.vendor_specific_module_def_ref = None      # *
+        self.ar_release_version = None                      # type: ARLiteral
+        self.behavior_ref = None                            # type: RefType
+        self.preconfiguredConfigurationRef = []             # type: List[RefType]
+        self.recommendedConfigurationRef = []               # type: List[RefType]
+        self.vendorApiInfix = None                          # type: str
+        self._vendorSpecificModuleDefRef = []               # type: List[RefType]
+
+    def addVendorSpecificModuleDefRef(self, ref: RefType):
+        self._vendorSpecificModuleDefRef.append(ref)
 
+    def getVendorSpecificModuleDefRefs(self):
+        return self._vendorSpecificModuleDefRef
+    
 class SwcImplementation(Implementation):
     def __init__(self, parent: ARObject, short_name: str) -> None:
         super().__init__(parent, short_name)
 
         self.behavior_ref = None                        # type: RefType
         self.per_instance_memory_size = None
-        self.required_rte_vendor = ""
+        self.required_rte_vendor = ""
+